| COPYRIGHT = """\ |
| /* |
| * Copyright 2017 Intel Corporation |
| * |
| * Permission is hereby granted, free of charge, to any person obtaining a |
| * copy of this software and associated documentation files (the |
| * "Software"), to deal in the Software without restriction, including |
| * without limitation the rights to use, copy, modify, merge, publish, |
| * distribute, sub license, and/or sell copies of the Software, and to |
| * permit persons to whom the Software is furnished to do so, subject to |
| * the following conditions: |
| * |
| * The above copyright notice and this permission notice (including the |
| * next paragraph) shall be included in all copies or substantial portions |
| * of the Software. |
| * |
| * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS |
| * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF |
| * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. |
| * IN NO EVENT SHALL VMWARE AND/OR ITS SUPPLIERS BE LIABLE FOR |
| * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, |
| * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE |
| * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. |
| */ |
| """ |
| |
| import argparse |
| import xml.etree.cElementTree as et |
| |
| from mako.template import Template |
| |
| from anv_extensions import * |
| |
| def _init_exts_from_xml(xml): |
| """ Walk the Vulkan XML and fill out extra extension information. """ |
| |
| xml = et.parse(xml) |
| |
| ext_name_map = {} |
| for ext in EXTENSIONS: |
| ext_name_map[ext.name] = ext |
| |
| for ext_elem in xml.findall('.extensions/extension'): |
| ext_name = ext_elem.attrib['name'] |
| if ext_name not in ext_name_map: |
| continue |
| |
| ext = ext_name_map[ext_name] |
| ext.type = ext_elem.attrib['type'] |
| |
| _TEMPLATE_H = Template(COPYRIGHT + """ |
| |
| #ifndef ANV_EXTENSIONS_H |
| #define ANV_EXTENSIONS_H |
| |
| #include "stdbool.h" |
| |
| #define ANV_INSTANCE_EXTENSION_COUNT ${len(instance_extensions)} |
| |
| extern const VkExtensionProperties anv_instance_extensions[]; |
| |
| struct anv_instance_extension_table { |
| union { |
| bool extensions[ANV_INSTANCE_EXTENSION_COUNT]; |
| struct { |
| %for ext in instance_extensions: |
| bool ${ext.name[3:]}; |
| %endfor |
| }; |
| }; |
| }; |
| |
| extern const struct anv_instance_extension_table anv_instance_extensions_supported; |
| |
| |
| #define ANV_DEVICE_EXTENSION_COUNT ${len(device_extensions)} |
| |
| extern const VkExtensionProperties anv_device_extensions[]; |
| |
| struct anv_device_extension_table { |
| union { |
| bool extensions[ANV_DEVICE_EXTENSION_COUNT]; |
| struct { |
| %for ext in device_extensions: |
| bool ${ext.name[3:]}; |
| %endfor |
| }; |
| }; |
| }; |
| |
| struct anv_physical_device; |
| |
| void |
| anv_physical_device_get_supported_extensions(const struct anv_physical_device *device, |
| struct anv_device_extension_table *extensions); |
| |
| #endif /* ANV_EXTENSIONS_H */ |
| """) |
| |
| _TEMPLATE_C = Template(COPYRIGHT + """ |
| #include "anv_private.h" |
| |
| #include "vk_util.h" |
| |
| /* Convert the VK_USE_PLATFORM_* defines to booleans */ |
| %for platform in ['ANDROID_KHR', 'WAYLAND_KHR', 'XCB_KHR', 'XLIB_KHR', 'DISPLAY_KHR', 'XLIB_XRANDR_EXT', 'FUCHSIA']: |
| #ifdef VK_USE_PLATFORM_${platform} |
| # undef VK_USE_PLATFORM_${platform} |
| # define VK_USE_PLATFORM_${platform} true |
| #else |
| # define VK_USE_PLATFORM_${platform} false |
| #endif |
| %endfor |
| |
| /* And ANDROID too */ |
| #ifdef ANDROID |
| # undef ANDROID |
| # define ANDROID true |
| #else |
| # define ANDROID false |
| #endif |
| |
| #define ANV_HAS_SURFACE (VK_USE_PLATFORM_WAYLAND_KHR || \\ |
| VK_USE_PLATFORM_XCB_KHR || \\ |
| VK_USE_PLATFORM_XLIB_KHR || \\ |
| VK_USE_PLATFORM_DISPLAY_KHR) |
| |
| static const uint32_t MAX_API_VERSION = ${MAX_API_VERSION.c_vk_version()}; |
| |
| VkResult anv_EnumerateInstanceVersion( |
| uint32_t* pApiVersion) |
| { |
| *pApiVersion = MAX_API_VERSION; |
| return VK_SUCCESS; |
| } |
| |
| const VkExtensionProperties anv_instance_extensions[ANV_INSTANCE_EXTENSION_COUNT] = { |
| %for ext in instance_extensions: |
| {"${ext.name}", ${ext.ext_version}}, |
| %endfor |
| }; |
| |
| const struct anv_instance_extension_table anv_instance_extensions_supported = { |
| %for ext in instance_extensions: |
| .${ext.name[3:]} = ${ext.enable}, |
| %endfor |
| }; |
| |
| uint32_t |
| anv_physical_device_api_version(struct anv_physical_device *device) |
| { |
| uint32_t version = 0; |
| |
| uint32_t override = vk_get_version_override(); |
| if (override) |
| return MIN2(override, MAX_API_VERSION); |
| |
| %for version in API_VERSIONS: |
| if (!(${version.enable})) |
| return version; |
| version = ${version.version.c_vk_version()}; |
| |
| %endfor |
| return version; |
| } |
| |
| const VkExtensionProperties anv_device_extensions[ANV_DEVICE_EXTENSION_COUNT] = { |
| %for ext in device_extensions: |
| {"${ext.name}", ${ext.ext_version}}, |
| %endfor |
| }; |
| |
| void |
| anv_physical_device_get_supported_extensions(const struct anv_physical_device *device, |
| struct anv_device_extension_table *extensions) |
| { |
| *extensions = (struct anv_device_extension_table) { |
| %for ext in device_extensions: |
| .${ext.name[3:]} = ${ext.enable}, |
| %endfor |
| }; |
| } |
| """) |
| |
| if __name__ == '__main__': |
| parser = argparse.ArgumentParser() |
| parser.add_argument('--out-c', help='Output C file.') |
| parser.add_argument('--out-h', help='Output H file.') |
| parser.add_argument('--xml', |
| help='Vulkan API XML file.', |
| required=True, |
| action='append', |
| dest='xml_files') |
| args = parser.parse_args() |
| |
| for filename in args.xml_files: |
| _init_exts_from_xml(filename) |
| |
| for ext in EXTENSIONS: |
| assert ext.type == 'instance' or ext.type == 'device' |
| |
| template_env = { |
| 'API_VERSIONS': API_VERSIONS, |
| 'MAX_API_VERSION': MAX_API_VERSION, |
| 'instance_extensions': [e for e in EXTENSIONS if e.type == 'instance'], |
| 'device_extensions': [e for e in EXTENSIONS if e.type == 'device'], |
| } |
| |
| if args.out_h: |
| with open(args.out_h, 'w') as f: |
| f.write(_TEMPLATE_H.render(**template_env)) |
| |
| if args.out_c: |
| with open(args.out_c, 'w') as f: |
| f.write(_TEMPLATE_C.render(**template_env)) |