module {PACKAGE_PREFIX};

public import {PACKAGE_PREFIX}.types;

public import {PACKAGE_PREFIX}.functions;\

module {PACKAGE_PREFIX}.types;

alias uint8_t = ubyte;

alias uint16_t = ushort;

alias uint32_t = uint;

alias uint64_t = ulong;

alias int8_t = byte;

alias int16_t = short;

alias int32_t = int;

alias int64_t = long;

@nogc nothrow:

pure {{

uint VK_MAKE_VERSION( uint major, uint minor, uint patch ) {{

return ( major << 22 ) | ( minor << 12 ) | ( patch );

}}

// Vulkan 1.0 version number

uint VK_API_VERSION_1_0() {{ return VK_MAKE_VERSION( 1, 0, 0 ); }}

uint VK_VERSION_MAJOR( uint ver ) {{ return ver >> 22; }}

uint VK_VERSION_MINOR( uint ver ) {{ return ( ver >> 12 ) & 0x3ff; }}

uint VK_VERSION_PATCH( uint ver ) {{ return ver & 0xfff; }}

}}

// Linkage of debug and allocation callbacks

extern( System ):

// Version of corresponding c header file

{HEADER_VERSION}

enum VK_NULL_HANDLE = null;

enum VK_DEFINE_HANDLE( string name ) = "struct "~name~"_handle; alias "~name~" = "~name~"_handle*;";

version( X86_64 ) {{

alias VK_DEFINE_NON_DISPATCHABLE_HANDLE( string name ) = VK_DEFINE_HANDLE!name;

enum VK_NULL_ND_HANDLE = null;

}} else {{

enum VK_DEFINE_NON_DISPATCHABLE_HANDLE( string name ) = "alias "~name~" = ulong;";

enum VK_NULL_ND_HANDLE = 0uL;

}}\

module {PACKAGE_PREFIX}.functions;

public import {PACKAGE_PREFIX}.types;

extern( System ) @nogc nothrow {{\

typ = elem.find( "type" )

typstr = ( elem.text or "" ).lstrip() + typ.text.strip() + ( typ.tail or "" ).rstrip()

# catch opaque structs

if typstr.startswith( 'struct' ):

typstr = typstr.lstrip( 'struct ' )

if isinstance( opaqueStruct, set ):

opaqueStruct.add( typstr.rstrip( '*' ))

arrlen = elem.find( "enum" )

if arrlen is not None:

return "{0}[ {1} ]".format( typstr, arrlen.text )

else:

name = elem.find( "name" )

"""

Converts C const syntax to D const syntax

"""

doubleConstMatch = re.match( re_double_const, typ )

if doubleConstMatch:

return "const( {0}* )*".format( doubleConstMatch.group( 1 ))

else:

singleConstMatch = re.match( re_single_const, typ )

if singleConstMatch:

return "const( {0} )*".format( singleConstMatch.group( 1 ))

arrMatch = re.match( re_array, name )

if arrMatch:

return "{0}[ {1} ]".format( typ, arrMatch.group( 2 )), arrMatch.group( 1 )

else:

# This is an ordered list of sections in the header file.

TYPE_SECTIONS = [ 'include', 'define', 'basetype', 'handle', 'enum', 'group', 'bitmask', 'funcpointer', 'struct' ]

ALL_SECTIONS = TYPE_SECTIONS + [ 'commandPointer', 'command' ]

def __init__( self, errFile = sys.stderr, warnFile = sys.stderr, diagFile = sys.stderr ):

super().__init__( errFile, warnFile, diagFile )

self.headerVersion = ""

self.typesFileContent = ""

self.opaqueStruct = set()

self.sections = dict( [ ( section, [] ) for section in self.ALL_SECTIONS ] )

self.functionTypeName = dict()

self.functionTypeDefinition = ""

self.instanceLevelFuncNames = set()

self.instanceLevelFunctions = ""

self.deviceLevelFuncNames = set()

self.deviceLevelFunctions = ""

self.dispatchTypeDefinition = ""

self.dispatchConvenienceFuncNames = dict()

self.dispatchConvenienceFunctions = ""

self.maxDispatchConvenienceFuncName = 0

self.platformExtensions = {

"// VK_KHR_android_surface" : [ "VK_USE_PLATFORM_ANDROID_KHR", "public import android.native_window;\n" ],

"// VK_KHR_mir_surface" : [ "VK_USE_PLATFORM_MIR_KHR", "public import mir_toolkit.client_types;\n" ],

"// VK_KHR_wayland_surface" : [ "VK_USE_PLATFORM_WAYLAND_KHR", "public import wayland.native.client;\n" ],

"// VK_KHR_win32_surface" : [ "VK_USE_PLATFORM_WIN32_KHR", "public import core.sys.windows.windows;\n" ],

"// VK_KHR_xlib_surface" : [ "VK_USE_PLATFORM_XLIB_KHR", "public import X11.Xlib;\n" ],

"// VK_EXT_acquire_xlib_display" : [ "VK_USE_PLATFORM_XLIB_KHR" , "" ],

"// VK_KHR_xcb_surface" : [ "VK_USE_PLATFORM_XCB_KHR", "public import xcb.xcb;\n" ],

"// VK_NV_external_memory_win32" : [ "VK_USE_PLATFORM_WIN32_KHR", "public import core.sys.windows.winnt;\n" ],

"// VK_KHR_external_memory_win32" : [ "VK_USE_PLATFORM_WIN32_KHR", "" ],

"// VK_NV_win32_keyed_mutex" : [ "VK_USE_PLATFORM_WIN32_KHR", "" ],

"// VK_KHX_win32_keyed_mutex" : [ "VK_USE_PLATFORM_WIN32_KHR", "" ],

"// VK_KHR_external_semaphore_win32" : [ "VK_USE_PLATFORM_WIN32_KHR", "" ],

"// VK_KHR_external_fence_win32" : [ "VK_USE_PLATFORM_WIN32_KHR", "" ],

}

def beginFile( self, genOpts ):

self.genOpts = genOpts

try:

os.mkdir( genOpts.filename )

except FileExistsError:

pass

self.typesFile = open( path.join( genOpts.filename, "types.d" ), "w", encoding = "utf-8" )

self.funcsFile = open( path.join( genOpts.filename, "functions.d" ), "w", encoding = "utf-8" )

#self.testsFile = open( path.join( genOpts.filename, "test.txt" ), "w", encoding = "utf-8" )

with open( path.join( genOpts.filename, "package.d" ), "w", encoding = "utf-8" ) as packageFile:

write( PACKAGE_HEADER.format( PACKAGE_PREFIX = genOpts.packagePrefix ), file = packageFile )

write( FUNCTIONS_HEADER.format( PACKAGE_PREFIX = genOpts.packagePrefix ), file = self.funcsFile )

def endFile( self ):

# write types.d file

write( TYPES_HEADER.format( PACKAGE_PREFIX = self.genOpts.packagePrefix, HEADER_VERSION = self.headerVersion ) + self.typesFileContent, file = self.typesFile )

# write functions.d file

write( "}}\n\n__gshared {{{GLOBAL_FUNCTION_DEFINITIONS}\n}}\n".format( GLOBAL_FUNCTION_DEFINITIONS = self.functionTypeDefinition ), file = self.funcsFile )

write( """\

/// if not using version "with-derelict-loader" this function must be called first

/// sets vkCreateInstance function pointer and acquires basic functions to retrieve information about the implementation

void loadGlobalLevelFunctions( typeof( vkGetInstanceProcAddr ) getProcAddr ) {

vkGetInstanceProcAddr = getProcAddr;

vkEnumerateInstanceExtensionProperties = cast( typeof( vkEnumerateInstanceExtensionProperties )) vkGetInstanceProcAddr( null, "vkEnumerateInstanceExtensionProperties" );

vkEnumerateInstanceLayerProperties = cast( typeof( vkEnumerateInstanceLayerProperties )) vkGetInstanceProcAddr( null, "vkEnumerateInstanceLayerProperties" );

vkCreateInstance = cast( typeof( vkCreateInstance )) vkGetInstanceProcAddr( null, "vkCreateInstance" );

}

/// with a valid VkInstance call this function to retrieve additional VkInstance, VkPhysicalDevice, ... related functions

void loadInstanceLevelFunctions( VkInstance instance ) {

assert( vkGetInstanceProcAddr !is null, "Must call loadGlobalLevelFunctions before loadInstanceLevelFunctions" );\

"""

+ self.instanceLevelFunctions

+ """\n\

}

/// with a valid VkInstance call this function to retrieve VkDevice, VkQueue and VkCommandBuffer related functions

/// the functions call indirectly through the VkInstance and will be internally dispatched by the implementation

/// use loadDeviceLevelFunctions( VkDevice device ) bellow to avoid this indirection and get the pointers directly form a VkDevice

void loadDeviceLevelFunctions( VkInstance instance ) {

assert( vkGetInstanceProcAddr !is null, "Must call loadInstanceLevelFunctions before loadDeviceLevelFunctions" );\

"""

+ self.deviceLevelFunctions.format( INSTANCE_OR_DEVICE = "Instance", instance_or_device = "instance" )

+ """\n\

}

/// with a valid VkDevice call this function to retrieve VkDevice, VkQueue and VkCommandBuffer related functions

/// the functions call directly VkDevice and related resources and can be retrieved for one and only one VkDevice

/// calling this function again with another VkDevices will overwrite the __gshared functions retrieved previously

/// use createGroupedDeviceLevelFunctions bellow if usage of multiple VkDevices is required

void loadDeviceLevelFunctions( VkDevice device ) {

assert( vkGetDeviceProcAddr !is null, "Must call loadInstanceLevelFunctions before loadDeviceLevelFunctions" );\

"""

+ self.deviceLevelFunctions.format( INSTANCE_OR_DEVICE = "Device", instance_or_device = "device" )

+ """\n\

}

/// with a valid VkDevice call this function to retrieve VkDevice, VkQueue and VkCommandBuffer related functions grouped in a DispatchDevice struct

/// the functions call directly VkDevice and related resources and can be retrieved for any VkDevice

deprecated( \"Use DispatchDevice( VkDevice ) or DispatchDevice.loadDeviceLevelFunctions( VkDevice ) instead\" )

DispatchDevice createDispatchDeviceLevelFunctions( VkDevice device ) {

return DispatchDevice( device );

}

// struct to group per device deviceLevelFunctions into a custom namespace

// keeps track of the device to which the functions are bound

struct DispatchDevice {

private VkDevice device = VK_NULL_HANDLE;

VkCommandBuffer commandBuffer;

// return copy of the internal VkDevice

VkDevice vkDevice() {

return device;

}

// Constructor forwards parameter 'device' to 'this.loadDeviceLevelFunctions'

this( VkDevice device ) {

this.loadDeviceLevelFunctions( device );

}

// load the device level member functions

// this also sets the private member 'device' to the passed in VkDevice

// now the DispatchDevice can be used e.g.:

// auto dd = DispatchDevice( device );

// dd.vkDestroyDevice( dd.vkDevice, pAllocator );

// convenience functions to omit the first arg do exist, see bellow

void loadDeviceLevelFunctions( VkDevice device ) {

assert( vkGetDeviceProcAddr !is null, "Must call loadInstanceLevelFunctions before loadDeviceLevelFunctions" );

this.device = device;\

"""

+ self.deviceLevelFunctions.format( INSTANCE_OR_DEVICE = "Device", instance_or_device = "device" ).replace( '\t', '\t\t' ).replace( '\t\t\t\t', '\t\t\t' )

+ """\n\

}

// Convenience member functions, forwarded to corresponding vulkan functions

// If the first arg of the vulkan function is VkDevice it can be omitted

// private 'DipatchDevice' member 'device' will be passed to the forwarded vulkan functions

// the crux is that function pointers can't be overloaded with regular functions

// hence the vk prefix is ditched for the convenience variants

// e.g.:

// auto dd = DispatchDevice( device );

// dd.DestroyDevice( pAllocator ); // instead of: dd.vkDestroyDevice( dd.vkDevice, pAllocator );

//

// Same mechanism works with functions which require a VkCommandBuffer as first arg

// In this case the public member 'commandBuffer' must be set beforehand

// e.g.:

// dd.commandBuffer = some_command_buffer;

// dd.BeginCommandBuffer( &beginInfo );

// dd.CmdBindPipeline( VK_PIPELINE_BIND_POINT_GRAPHICS, some_pipeline );

//

// Does not work with queues, there are just too few queue related functions"""

+ self.dispatchConvenienceFunctions

+ """\n\

// Member vulkan function decelerations{DISPATCH_FUNCTION_DEFINITIONS}

}}

// Derelict loader to acquire entry point vkGetInstanceProcAddr

version( {NAME_PREFIX_UCASE}_FROM_DERELICT ) {{

import derelict.util.loader;

import derelict.util.system;

private {{

version( Windows )

enum libNames = "vulkan-1.dll";

else version( Posix )

enum libNames = "libvulkan.so.1";

else

static assert( 0,"Need to implement Vulkan libNames for this operating system." );

}}

class Derelict{NAME_PREFIX}Loader : SharedLibLoader {{

this() {{

super( libNames );

}}

protected override void loadSymbols() {{

typeof( vkGetInstanceProcAddr ) getProcAddr;

bindFunc( cast( void** )&getProcAddr, "vkGetInstanceProcAddr" );

loadGlobalLevelFunctions( getProcAddr );

}}

}}

__gshared Derelict{NAME_PREFIX}Loader Derelict{NAME_PREFIX};

shared static this() {{

Derelict{NAME_PREFIX} = new Derelict{NAME_PREFIX}Loader();

}}

}}

""".format(

NAME_PREFIX = self.genOpts.namePrefix,

NAME_PREFIX_UCASE = self.genOpts.namePrefix.upper(),

DISPATCH_FUNCTION_DEFINITIONS = self.dispatchTypeDefinition ),

file = self.funcsFile )

self.typesFile.close()

self.funcsFile.close()

def beginFeature( self, interface, emit ):

OutputGenerator.beginFeature( self, interface, emit )

#if interface.attrib.get( 'protect' ):

#write( interface.attrib[ 'name' ], file = self.testsFile )

self.currentFeature = "// {0}".format( interface.attrib[ 'name' ] )

self.sections = dict( [ ( section, [] ) for section in self.ALL_SECTIONS ] )

self.opaqueStruct.clear()

self.platformExtensionVersionIndent = ""

self.isPlatformExtension = self.currentFeature in self.platformExtensions

if self.isPlatformExtension:

self.platformExtensionVersionIndent = "\t"

def endFeature( self ):

if self.emit:

# first write all types into types.d

# special treat for platform surface extension which get wrapped into a version block

extIndent = self.platformExtensionVersionIndent

fileContent = self.typesFileContent

fileContent += "\n{0}\n".format( self.currentFeature )

version_platform = ""

if self.isPlatformExtension:

version_platform = "version( {0} ) {{".format( self.platformExtensions[ self.currentFeature ][ 0 ] )

fileContent += "{0}\n\t{1}\n".format( version_platform, self.platformExtensions[ self.currentFeature ][ 1 ] )

isFirstSectionInFeature = True # for output file formating

for section in self.TYPE_SECTIONS:

# write contents of type section

contents = self.sections[ section ]

if contents:

# check if opaque structs were registered and write them into types file

if section == 'struct':

if self.opaqueStruct:

for opaque in self.opaqueStruct:

# special handling for wayland

if opaque == "wl_display":

continue

elif opaque == "wl_surface":

fileContent += "{0}alias wl_surface = wl_proxy;\n".format( extIndent );

else:

fileContent += "{1}struct {0};\n".format( opaque, extIndent )

fileContent += '\n'

elif not isFirstSectionInFeature:

fileContent += '\n'

# for output file formating

isFirstSectionInFeature = False

# write the rest of the contents, eg. enums, structs, etc. into types file

for content in self.sections[ section ]:

fileContent += "{1}{0}\n".format( content, extIndent )

if self.isPlatformExtension:

fileContent += "}\n"

self.typesFileContent = fileContent

fileContent = ""

# currently the commandPointer token is not used by Khronos

if self.genOpts.genFuncPointers and self.sections[ 'commandPointer' ]:

if self.isPlatformExtension: fileContent += version_platform#write( version_platform, file = self.funcsFile )

fileContent += '\n' + extIndent + ( '\n' + extIndent ).join( self.sections[ 'commandPointer' ] ) #write( extIndent + ( '\n' + extIndent ).join( self.sections[ 'commandPointer' ] ), file = self.funcsFile )

if self.isPlatformExtension: fileContent += "\n}" #write( "}", file = self.funcsFile )

fileContent += '\n' #write( '', file = self.funcsFile )

write( fileContent, file = self.funcsFile )

fileContent = ""

# write function aliases into functions.d and build strings for later injection

if self.sections[ 'command' ]:

# update indention of currentFeature for functions.d content

self.currentFeature = "\t" + self.currentFeature;

# write the aliases to function types

fileContent += "\n{0}".format( self.currentFeature ) #write( "\n{0}".format( self.currentFeature ), file = self.funcsFile )

if self.isPlatformExtension: fileContent += "\n\t" + version_platform #write( "\t" + version_platform, file = self.funcsFile )

fileContent += "\n" + extIndent + ( '\n' + extIndent ).join( self.sections[ 'command' ] ) #write( extIndent + ( '\n' + extIndent ).join( self.sections[ 'command' ] ), file = self.funcsFile )

if self.isPlatformExtension: fileContent += "\n\t}" #write( "\t}", file = self.funcsFile )

write( fileContent, file = self.funcsFile )

fileContent = ""

# capture if function is a instance or device level function

inInstanceLevelFuncNames = False

inDeviceLevelFuncNames = False

inDispatchConvenienceFuncNames = False

# comment the current feature

self.functionTypeDefinition += "\n\n{0}".format( self.currentFeature )

# surface extension version directive

if self.isPlatformExtension: self.functionTypeDefinition += "\n\t" + version_platform

# create string of functionTypes functionVars

for command in self.sections[ 'command' ]:

name = self.functionTypeName[ command ]

self.functionTypeDefinition += "\n\t{1}PFN_{0} {0};".format( name, extIndent )

# query if the current function is in instance or deviceLevelFuncNames for the next step

if not inInstanceLevelFuncNames and name in self.instanceLevelFuncNames:

inInstanceLevelFuncNames = True

if not inDeviceLevelFuncNames and name in self.deviceLevelFuncNames:

inDeviceLevelFuncNames = True

inDispatchConvenienceFuncNames = name in self.dispatchConvenienceFuncNames

# surface extension version closing curly brace

if self.isPlatformExtension: self.functionTypeDefinition += "\n\t}"

# create a strings to load instance level functions

if inInstanceLevelFuncNames:

# comment the current feature

self.instanceLevelFunctions += "\n\n{0}".format( self.currentFeature )

# surface extension version directive

if self.isPlatformExtension: self.instanceLevelFunctions += "\n\t" + version_platform

# set of global level function names, function pointers are ignored here are set in endFile method

gloablLevelFuncNames = {"vkGetInstanceProcAddr", "vkEnumerateInstanceExtensionProperties", "vkEnumerateInstanceLayerProperties", "vkCreateInstance"}

# build the commands

for command in self.sections[ 'command' ]:

name = self.functionTypeName[ command ]

if name in self.instanceLevelFuncNames and name not in gloablLevelFuncNames:

self.instanceLevelFunctions += "\n\t{1}{0} = cast( typeof( {0} )) vkGetInstanceProcAddr( instance, \"{0}\" );".format( name, extIndent )

# surface extension version closing curly brace

if self.isPlatformExtension:

self.instanceLevelFunctions += "\n\t}"

# create a string to load device level functions

if inDeviceLevelFuncNames:

# comment the current feature

self.deviceLevelFunctions += "\n\n{0}".format( self.currentFeature )

# surface extension version directive

if self.isPlatformExtension:

# add version_platform into the DispatchDevice struct

self.dispatchTypeDefinition += "\n\t" + version_platform

# need to change version platform due to INSTANCE_OR_DEVICE format element

version_platform = "version( {0} ) {{{{".format( self.platformExtensions[ self.currentFeature[1:] ][ 0 ] )

self.deviceLevelFunctions += "\n\t" + version_platform

# build the commands

for command in self.sections[ 'command' ]:

name = self.functionTypeName[ command ]

if name in self.deviceLevelFuncNames:

self.deviceLevelFunctions += "\n\t{1}{0} = cast( typeof( {0} )) vkGet{{INSTANCE_OR_DEVICE}}ProcAddr( {{instance_or_device}}, \"{0}\" );".format( name, extIndent )

# this function type definitions end up in the DispatchDevice struct

self.dispatchTypeDefinition += "\n\t{1}PFN_{0} {0};".format( name, extIndent )

# surface extension version closing curly brace

if self.isPlatformExtension:

self.deviceLevelFunctions += "\n\t}}" # closing braces for formated device level functions

self.dispatchTypeDefinition += "\n\t}" # closing braces for unformated dispatch device struct

# create a string for DispatchDevice convenience functions

if inDispatchConvenienceFuncNames:

# comment the current feature

self.dispatchConvenienceFunctions += "\n\n{0}".format( self.currentFeature )

# surface extension version directive

if self.isPlatformExtension:

# need to change version platform due to INSTANCE_OR_DEVICE format element

version_platform = "version( {0} ) {{".format( self.platformExtensions[ self.currentFeature[1:] ][ 0 ] )

self.dispatchConvenienceFunctions += "\n\t" + version_platform

# build the commands

for command in self.sections[ 'command' ]:

name = self.functionTypeName[ command ]

if name in self.dispatchConvenienceFuncNames:

self.dispatchConvenienceFunctions += '\n' + self.dispatchConvenienceFuncNames[ name ].format( extIndent )

# surface extension version closing curly brace

if self.isPlatformExtension:

self.dispatchConvenienceFunctions += "\n\t}" # closing braces for formated device level functions

# Finish processing in superclass

OutputGenerator.endFeature( self )

# Append a definition to the specified section

def appendSection( self, section, text ):

self.sections[ section ].append( text )

def genType( self, typeinfo, name ):

super().genType( typeinfo, name )

if "requires" in typeinfo.elem.attrib:

required = typeinfo.elem.attrib[ "requires" ]

if required.endswith( ".h" ):

return

elif required == "vk_platform":

return

if "category" not in typeinfo.elem.attrib:

#for k, v in typeinfo.elem.attrib.items():

# write( k, v, file = self.testsFile )

return

category = typeinfo.elem.attrib[ "category" ]

if category == "handle":

self.appendSection( "handle", "mixin( {0}!q{{{1}}} );".format( typeinfo.elem.find( "type" ).text, name ))

elif category == "basetype":

self.appendSection( "basetype", "alias {0} = {1};".format( name, typeinfo.elem.find( "type" ).text ))

elif category == "bitmask":

self.appendSection( "bitmask", "alias {0} = VkFlags;".format( name ))

elif category == "funcpointer":

returnType = re.match( re_funcptr, typeinfo.elem.text ).group( 1 )

params = "".join( islice( typeinfo.elem.itertext(), 2, None ))[ 2: ]

if params == "void);" or params == " void );" : params = ");"

#else: params = ' '.join( ' '.join( line.strip() for line in params.splitlines()).split())

else:

concatParams = ""

for line in params.splitlines():

lineSplit = line.split()

if len( lineSplit ) > 2:

concatParams += ' ' + convertTypeConst( lineSplit[ 0 ] + ' ' + lineSplit[ 1 ] ) + ' ' + lineSplit[ 2 ]

else:

concatParams += ' ' + ' '.join( param for param in lineSplit )

params = concatParams[ 2: ]

self.appendSection( "funcpointer", "alias {0} = {1} function( {2}".format( name, returnType, params ))

#write( params, file = self.testsFile )

elif category == "struct" or category == "union":

self.genStruct( typeinfo, name )

elif category == 'define' and name == 'VK_HEADER_VERSION':

for headerVersion in islice( typeinfo.elem.itertext(), 2, 3 ): # get the version string from the one element list

self.headerVersion = "enum VK_HEADER_VERSION = {0};".format( headerVersion )

else:

pass

def genStruct( self, typeinfo, name ):

super().genStruct( typeinfo, name )

category = typeinfo.elem.attrib[ "category" ]

self.appendSection( "struct", "\n{2}{0} {1} {{".format( category, name, self.platformExtensionVersionIndent ))

targetLen = 0

memberTypeName = []

for member in typeinfo.elem.findall( "member" ):

memberType = convertTypeConst( getFullType( member, self.opaqueStruct ).strip())

memberName = member.find( "name" ).text

if memberName == "module":

# don't use D identifiers

memberName = "_module"

if member.get( "values" ):

memberName += " = " + member.get( "values" )

#write( memberName, file = self.testsFile )

# get the maximum string length of all member types

memberType, memberName = convertTypeArray( memberType, memberName )

memberTypeName.append( ( memberType, memberName ))

targetLen = max( targetLen, len( memberType ))

# loop second time and use maximum type string length to offset member names

for type_name in memberTypeName:

self.appendSection( "struct", "\t{0} {1};".format( type_name[0].ljust( targetLen ), type_name[1] ))

self.appendSection( "struct", "}" )

def genGroup( self, groupinfo, groupName ):

super().genGroup( groupinfo, groupName )

groupElem = groupinfo.elem

expandName = re.sub( r'([0-9a-z_])([A-Z0-9][^A-Z0-9]?)', r'\1_\2', groupName ).upper()

expandPrefix = expandName

expandSuffix = ''

expandSuffixMatch = re.search( r'[A-Z][A-Z]+$', groupName )

if expandSuffixMatch:

expandSuffix = '_' + expandSuffixMatch.group()

# Strip off the suffix from the prefix

expandPrefix = expandName.rsplit( expandSuffix, 1 )[ 0 ]

# group enums by their name

body = "\nenum " + groupName + " {\n"

# add grouped enums to global scope

globalEnums = "\n\n// " + groupName + " global enums\n"

isEnum = ( 'FLAG_BITS' not in expandPrefix )

# Loop over the nested 'enum' tags. Keep track of the minimum and

# maximum numeric values, if they can be determined; but only for

# core API enumerants, not extension enumerants. This is inferred

# by looking for 'extends' attributes.

minName = None

for elem in groupElem.findall( 'enum' ):

# Convert the value to an integer and use that to track min/max.

# Values of form -( number ) are accepted but nothing more complex.

# Should catch exceptions here for more complex constructs. Not yet.

( numVal, strVal ) = self.enumToValue( elem, True )

name = elem.get( 'name' )

# Extension enumerants are only included if they are requested

# in addExtensions or match defaultExtensions.

if ( elem.get( 'extname' ) is None or

re.match( self.genOpts.addExtensions, elem.get( 'extname' )) is not None or

self.genOpts.defaultExtensions == elem.get( 'supported' )):

body += "\t" + name + " = " + strVal + ",\n"

globalEnums += "enum {0} = {1}.{0};\n".format( name, groupName )

if isEnum and elem.get( 'extends' ) is None:

if minName is None:

minName = maxName = name

minValue = maxValue = numVal

elif numVal < minValue:

minName = name

minValue = numVal

elif numVal > maxValue:

maxName = name

maxValue = numVal

# Generate min/max value tokens and a range-padding enum. Need some

# additional padding to generate correct names...

if isEnum:

body += "\t" + expandPrefix + "_BEGIN_RANGE" + expandSuffix + " = " + minName + ",\n"

body += "\t" + expandPrefix + "_END_RANGE" + expandSuffix + " = " + maxName + ",\n"

body += "\t" + expandPrefix + "_RANGE_SIZE" + expandSuffix + " = ( " + maxName + " - " + minName + " + 1 ),\n"

globalEnums += "enum {0}{1}{2} = {3}.{0}{1}{2};\n".format( expandPrefix, "_BEGIN_RANGE", expandSuffix, groupName )

globalEnums += "enum {0}{1}{2} = {3}.{0}{1}{2};\n".format( expandPrefix, "_END_RANGE" , expandSuffix, groupName )

globalEnums += "enum {0}{1}{2} = {3}.{0}{1}{2};\n".format( expandPrefix, "_RANGE_SIZE" , expandSuffix, groupName )

body += "\t" + expandPrefix + "_MAX_ENUM" + expandSuffix + " = 0x7FFFFFFF\n}"

globalEnums += "enum {0}{1}{2} = {3}.{0}{1}{2};".format( expandPrefix, "_MAX_ENUM" , expandSuffix, groupName )

if groupElem.get( 'type' ) == 'bitmask':

self.appendSection( 'bitmask', body + globalEnums )

else:

self.appendSection( 'group', body + globalEnums )

def genEnum( self, enuminfo, name ):

super().genEnum( enuminfo, name )

_,strVal = self.enumToValue( enuminfo.elem, False )

if strVal == "VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT":

strVal = "VkStructureType." + strVal

strVal = re.sub( re_long_int, "\g<1>UL", strVal )

self.appendSection( 'enum', "enum {0} = {1};".format( name, strVal ))

def genCmd( self, cmdinfo, name ):

#if name not in {"vkGetInstanceProcAddr", "vkEnumerateInstanceExtensionProperties", "vkEnumerateInstanceLayerProperties", "vkCreateInstance"}:

super().genCmd( cmdinfo, name )

proto = cmdinfo.elem.find( "proto" )

returnType = convertTypeConst( getFullType( proto ).strip())

#write( returnType, file = self.testsFile )

params = cmdinfo.elem.findall( "param" )

joinedParams = ", ".join( convertTypeConst( getFullType( param, self.opaqueStruct ).strip()) + " " + param.find( "name" ).text for param in params )

funcTypeName = "\talias PFN_{0} = {1} function( {2} );".format( name, returnType, joinedParams )

self.appendSection( 'command', funcTypeName )

self.functionTypeName[ funcTypeName ] = name

if name != "vkGetDeviceProcAddr" and getFullType( params[ 0 ] ) in { "VkDevice", "VkQueue", "VkCommandBuffer" }:

self.deviceLevelFuncNames.add( name )

doReturn = ""

if returnType != "void":

doReturn = "return "

joinedArgs = ""

if len( params[1:] ):

joinedArgs = ", " + ", ".join( param.find( "name" ).text for param in params[1:] )

joinedParams = ", ".join( convertTypeConst( getFullType( param, self.opaqueStruct ).strip()) + " " + param.find( "name" ).text for param in params[1:] )

self.maxDispatchConvenienceFuncName = max( len( returnType ) + 2 + len( name ) + 2 + len( joinedParams ) + 2, self.maxDispatchConvenienceFuncName )

# create convenience functions for DispatchDevice

if getFullType( params[ 0 ] ) == "VkDevice":

forwardFuncs = "\t{{0}}{0} {1}( {2} ) {{{{\n{{0}}\t\t{3}{4}( this.device{5} );\n{{0}}\t}}}}".format(

returnType, name[2:], joinedParams, doReturn, name, joinedArgs ).replace( '( )', '()' )

self.dispatchConvenienceFuncNames[ name ] = forwardFuncs

#write( forwardFuncs, file = self.testsFile )

elif getFullType( params[ 0 ] ) == "VkCommandBuffer":

forwardFuncs = "{{0}}\t{0} {1}( {2} ) {{{{\n{{0}}\t\t{3}{4}( this.commandBuffer{5} );\n{{0}}\t}}}}".format(

returnType, name[2:], joinedParams, doReturn, name, joinedArgs ).replace( '( )', '()' )

self.dispatchConvenienceFuncNames[ name ] = forwardFuncs

#write( forwardFuncs, file = self.testsFile )

#else: #elif getFullType( params[ 0 ] ) == "VkQueue":

#forwardFuncs = "\t{0} {1}( {2} ) {{ queue.{1}( {4} ); }}".format( returnType, name, joinedParams, joinedArgs ).replace( '( )', '()' )

#self.dispatchConvenienceFuncNames[ name ] = forwardFuncs

#write( forwardFuncs, file = self.testsFile )

else:

def __init__( self, *args, **kwargs ):

self.packagePrefix = kwargs.pop( "packagePrefix" )

self.namePrefix = kwargs.pop( "namePrefix" )

self.genFuncPointers = kwargs.pop( "genFuncPointers" )