VulkanHeaders: generate sType as const with default value

Also add a script to generate all the headers we need along with function loading.

Author: VReaperV

libs/VulkanHeaders/GenerateAll.py

@@ -0,0 +1,47 @@
+from os import system, remove
+
+headers = [
+	( "vulkan_core",        "w", "" ),
+	( "vulkan_beta",        "a", "VK_ENABLE_BETA_EXTENSIONS" ),
+	( "vulkan_win32",       "a", "VK_USE_PLATFORM_WIN32_KHR" ),
+	( "vulkan_wayland",     "a", "VK_USE_PLATFORM_WAYLAND_KHR" ),
+	( "vulkan_xlib",        "a", "VK_USE_PLATFORM_XLIB_KHR" ),
+	( "vulkan_xlib_xrandr", "a", "VK_USE_PLATFORM_XLIB_XRANDR_EXT" )
+]
+
+with open( "FunctionDecls.h", "w" ) as f:
+	with open( "FunctionLoaderInstance.cpp", "w" ) as f1:
+		with open( "FunctionLoaderDevice.cpp", "w" ) as f2:
+			print( "" )
+
+vulkanLoaderPath = "../../src/engine/renderer-vulkan/VulkanLoader/"
+
+for header in headers:
+	if header[2]:
+		define = " -define " + header[2]
+	else:
+		define = ""
+	system( "python genvk.py -o " + vulkanLoaderPath + "vulkan/ -apiname vulkan -mode " + header[1] + define + " " + header[0] + ".h" )
+
+with open( "FunctionDecls.h", "r" ) as inp:
+	with open( vulkanLoaderPath + "Vulkan.h", "w" ) as out:
+		out.write( inp.read() )
+		out.write( '#endif // VULKAN_LOADER_H' )
+
+with open( 'VulkanLoadFunctions.cpp', mode = 'r', encoding = 'utf-8', newline = '\n' ) as inp:
+	functionLoadStart = inp.read()
+
+with open( "FunctionLoaderInstance.cpp", "r" ) as inp:
+	with open( "FunctionLoaderDevice.cpp", "r" ) as inp2:
+		with open( vulkanLoaderPath + "VulkanLoadFunctions.cpp", "w" ) as out:
+			out.write( functionLoadStart )
+			out.write( '\n\nvoid VulkanLoadInstanceFunctions( VkInstance instance ) {\n' )
+			out.write( inp.read() )
+			out.write( '}\n\n' )
+			out.write( 'void VulkanLoadDeviceFunctions( VkDevice device ) {\n' )
+			out.write( inp2.read() )
+			out.write( '}' )
+
+remove( "FunctionDecls.h" )
+remove( "FunctionLoaderInstance.cpp" )
+remove( "FunctionLoaderDevice.cpp" )

libs/VulkanHeaders/Globals.py

@@ -0,0 +1,12 @@
+def init():
+    global headerText
+    global functionDefinitionsText
+
+    global functionLoadInstanceText
+    global functionLoadDeviceText
+    
+    headerText = ''
+    functionDefinitionsText = ''
+
+    functionLoadInstanceText = ''
+    functionLoadDeviceText   = ''

libs/VulkanHeaders/Vulkan.cpp

@@ -0,0 +1,4 @@
+// Auto-generated, do not modify
+
+#include "Vulkan.h"
+

libs/VulkanHeaders/Vulkan.h

@@ -0,0 +1,14 @@
+// Auto-generated, do not modify
+
+#ifndef VULKAN_LOADER_H
+#define VULKAN_LOADER_H
+
+#ifdef _MSC_VER
+	#define VK_USE_PLATFORM_WIN32_KHR
+#endif
+
+#define VK_ENABLE_BETA_EXTENSIONS
+
+#include "vulkan/vulkan.h"
+#include "vulkan/vk_enum_string_helper.h"
+

libs/VulkanHeaders/VulkanLoadFunctions.cpp

@@ -0,0 +1,43 @@
+// Auto-generated, do not modify
+
+#ifdef _MSC_VER
+	#include <windows.h>
+#else
+	#include <dlfcn.h>
+#endif
+
+#include "Vulkan.h"
+
+#include "VulkanLoadFunctions.h"
+
+#ifdef _MSC_VER
+	HMODULE libVulkan;
+#else
+	void*   libVulkan;
+#endif
+
+void VulkanLoaderInit() {
+	#ifdef _MSC_VER
+		libVulkan = LoadLibrary( "vulkan-1.dll" );
+		vkGetInstanceProcAddr = ( PFN_vkGetInstanceProcAddr ) GetProcAddress( libVulkan, "vkGetInstanceProcAddr" );
+	#else
+		libVulkan = dlopen( "libvulkan.so", RTLD_NOW );
+		vkGetInstanceProcAddr = dlsym( libVulkan, "vkGetInstanceProcAddr" );
+	#endif
+
+	vkEnumerateInstanceVersion = ( PFN_vkEnumerateInstanceVersion ) vkGetInstanceProcAddr( nullptr, "vkEnumerateInstanceVersion" );
+
+	vkEnumerateInstanceExtensionProperties = ( PFN_vkEnumerateInstanceExtensionProperties ) vkGetInstanceProcAddr( nullptr, "vkEnumerateInstanceExtensionProperties" );
+
+	vkEnumerateInstanceLayerProperties = ( PFN_vkEnumerateInstanceLayerProperties ) vkGetInstanceProcAddr( nullptr, "vkEnumerateInstanceLayerProperties" );
+
+	vkCreateInstance = ( PFN_vkCreateInstance ) vkGetInstanceProcAddr( nullptr, "vkCreateInstance" );
+}
+
+void VulkanLoaderFree() {
+	#ifdef _MSC_VER
+		FreeLibrary( libVulkan );
+	#else
+		dlclose( libVulkan );
+	#endif
+}

libs/VulkanHeaders/generator.py

@@ -21,6 +21,7 @@
 
 from spec_tools.util import getElemName, getElemType
 
+import Globals
 
 def write(*args, **kwargs):
     file = kwargs.pop('file', sys.stdout)
@@ -1124,6 +1125,12 @@ def makeCParamDecl(self, param, aligncol):
             text = noneStr(elem.text)
             tail = noneStr(elem.tail)
 
+            if text.endswith( 'sType' ):
+                sType = param.get( 'values' )
+                
+                if sType:
+                    text += ' = ' + sType
+
             if self.should_insert_may_alias_macro and self.genOpts.conventions.is_voidpointer_alias(elem.tag, text, tail):
                 # OpenXR-specific macro insertion - but not in apiinc for the spec
                 tail = self.genOpts.conventions.make_voidpointer_alias(tail)
@@ -1351,14 +1358,27 @@ def makeCDecls(self, cmd):
         # Leading text
         pdecl += noneStr(proto.text)
         tdecl += noneStr(proto.text)
+
         # For each child element, if it is a <name> wrap in appropriate
         # declaration. Otherwise append its contents and tail contents.
+        functionName = None
+        deviceFunction = True
         for elem in proto:
             text = noneStr(elem.text)
             tail = noneStr(elem.tail)
+
             if elem.tag == 'name':
                 pdecl += self.makeProtoName(text, tail)
                 tdecl += self.makeTypedefName(text, tail)
+
+                Globals.headerText              += 'extern PFN_' + text + ' ' + text + ';\n\n'
+                Globals.functionDefinitionsText +=        'PFN_' + text + ' ' + text + ';\n\n'
+                
+                if not text.endswith( ( 'vkGetInstanceProcAddr', 'vkEnumerateInstanceVersion', 'vkEnumerateInstanceExtensionProperties', 'vkEnumerateInstanceLayerProperties', 'vkCreateInstance', 'vkDestroyInstance' ) ):
+                    functionName = text
+
+                    if text == 'vkGetDeviceProcAddr':
+                        deviceFunction = False
             else:
                 pdecl += text + tail
                 tdecl += text + tail
@@ -1376,6 +1396,22 @@ def makeCDecls(self, cmd):
         # self.indentFuncPointer
         # self.alignFuncParam
         n = len(params)
+
+        if n > 0 and functionName:
+            for p in params:
+                for elem in p:
+                    if deviceFunction and noneStr( elem.text ).endswith( ( 'VkInstance', 'VkPhysicalDevice', 'VkPhysicalDeviceGroup' ) ):
+                        deviceFunction = False
+                        break
+
+                if not deviceFunction:
+                    break
+                    
+            if deviceFunction:
+                Globals.functionLoadDeviceText    += '\t' + functionName + ' = ( PFN_' + functionName + ' ) vkGetDeviceProcAddr( device, "'     + functionName + '" );\n\n'
+            else:
+                Globals.functionLoadInstanceText  += '\t' + functionName + ' = ( PFN_' + functionName + ' ) vkGetInstanceProcAddr( instance, "' + functionName + '" );\n\n'
+
         # Indented parameters
         if n > 0:
             indentdecl = '(\n'

libs/VulkanHeaders/genvk.py

@@ -1105,6 +1105,10 @@ def genTarget(args):
                         help='generate MISRA C++-friendly headers')
     parser.add_argument('--iscts', action='store_true', dest='isCTS',
                         help='Specify if this should generate CTS compatible code')
+    parser.add_argument('-mode', action='store',
+                        help='w - write, a - append')
+    parser.add_argument('-define', action='store',
+                        help='Pe-processor define to use')
 
     args = parser.parse_args()
 
@@ -1148,12 +1152,16 @@ def genTarget(args):
         logDiag('* Dumping registry to regdump.txt')
         reg.dumpReg(filehandle=open('regdump.txt', 'w', encoding='utf-8'))
 
+    if not args.mode in ( 'w', 'a' ):
+        print( 'Unknown mode: ' + args.mode + '\nAvailable modes: w, a' )
+        exit( -1 )
+
     # Finally, use the output generator to create the requested target
     if args.debug:
         pdb.run('reg.apiGen()')
     else:
         startTimer(args.time)
-        reg.apiGen()
+        reg.apiGen( args.registry.rstrip( 'vk.xml' ), args.directory, args.mode, args.define )
         endTimer(args.time, f"* Time to generate {options.filename} =")
 
     if not args.quiet:

libs/VulkanHeaders/reg.py

@@ -15,6 +15,8 @@
 from generator import GeneratorOptions, OutputGenerator, noneStr, write
 from apiconventions import APIConventions
 
+import Globals
+
 def apiNameMatch(str, supported):
     """Return whether a required api name matches a pattern specified for an
     XML <feature> 'api' attribute or <extension> 'supported' attribute.
@@ -1656,7 +1658,7 @@ def tagValidExtensionStructs(self):
         for parent in self.validextensionstructs:
             self.validextensionstructs[parent].sort()
 
-    def apiGen(self):
+    def apiGen(self, inputDir, outputDir, mode, define):
         """Generate interface for specified versions using the current
         generator and generator options"""
 
@@ -1844,6 +1846,18 @@ def apiGen(self):
         #   generated.
         self.gen.logMsg('diag', 'PASS 3: GENERATE INTERFACES FOR FEATURES')
         self.gen.beginFile(self.genOpts)
+        
+        headerStart = ''
+        functionLoadStart = ''
+        if mode == "w":
+            with open( inputDir + 'Vulkan.h', mode = 'r', encoding = 'utf-8', newline = '\n' ) as inp:
+                headerStart = inp.read()
+                
+            with open( inputDir + 'VulkanLoadFunctions.cpp', mode = 'r', encoding = 'utf-8', newline = '\n' ) as inp:
+                functionLoadStart = inp.read()
+
+        Globals.init()
+
         for f in features:
             self.gen.logMsg('diag', 'PASS 3: Generating interface for',
                             f.name)
@@ -1870,6 +1884,59 @@ def apiGen(self):
         for s in self.syncpipelinedict:
             self.generateSyncPipeline(self.syncpipelinedict[s])
         self.gen.endFile()
+        
+        outputDir = outputDir.rstrip( '/' ).rsplit( '/', 1 )[0] + '/'
+        
+        indent = "\t" if define else ""
+        
+        with open( 'FunctionDecls.h', mode = mode, encoding = 'utf-8', newline = '\n' ) as out:
+            if define:
+                out.write( "#if defined( " + define + " )\n" )
+            
+            out.write( headerStart + indent + Globals.headerText )
+
+            if define:
+                out.write( "#endif\n\n" )
+        
+        with open( outputDir + 'Vulkan.cpp', mode = mode, encoding = 'utf-8', newline = '\n' ) as out:
+            if mode == "w":
+                out.write( '// Auto-generated, do not modify\n\n' )
+                out.write( '#include "Vulkan.h"\n\n' )
+            
+            if define:
+                out.write( "#if defined( " + define + " )\n" )
+            
+            out.write( indent + Globals.functionDefinitionsText )
+
+            if define:
+                out.write( "#endif\n\n" )
+        
+        #with open( outputDir + 'VulkanLoadFunctions.cpp', mode = mode, encoding = 'utf-8', newline = '\n' ) as out:
+        #    out.write( functionLoadStart )
+        #    out.write( '\n\nvoid VulkanLoadInstanceFunctions( VkInstance instance ) {\n' )
+        #    out.write( Globals.functionLoadInstanceText )
+        #    out.write( '}\n\n' )
+        #    out.write( 'void VulkanLoadDeviceFunctions( VkDevice device ) {\n' )
+        #    out.write( Globals.functionLoadDeviceText )
+        #    out.write( '}' )
+        
+        with open( 'FunctionLoaderInstance.cpp', mode = mode, encoding = 'utf-8', newline = '\n' ) as out:
+            if define:
+                out.write( "#if defined( " + define + " )\n" )
+            
+            out.write( Globals.functionLoadInstanceText )
+
+            if define:
+                out.write( "#endif\n\n" )
+        
+        with open( 'FunctionLoaderDevice.cpp', mode = mode, encoding = 'utf-8', newline = '\n' ) as out:
+            if define:
+                out.write( "#if defined( " + define + " )\n" )
+            
+            out.write( Globals.functionLoadDeviceText )
+
+            if define:
+                out.write( "#endif\n\n" )
 
     def apiReset(self):
         """Reset type/enum/command dictionaries before generating another API.