Merge branch 'master' of ssh://github.com/86Box/86Box into cleanup30

2026-02-21 17:15:32 -07:00 · 2022-07-08 19:22:52 -03:00
parent 50b75c457d 95c264d98e
commit 9bdec4a1d9
101 changed files with 224686 additions and 859 deletions
--- a/.ci/Jenkinsfile
+++ b/.ci/Jenkinsfile
@@ -90,8 +90,8 @@ def presetSlugs = [

 def presetFlags = [
 	'Regular': '-t --preset=regular -D CMAKE_BUILD_TYPE=Release',
-	'Debug': '--preset=debug -D CMAKE_BUILD_TYPE=Debug',
-	'Dev': '--preset=experimental -D CMAKE_BUILD_TYPE=Debug -D VNC=OFF'
+	'Debug': '--preset=debug -D CMAKE_BUILD_TYPE=Debug -D STATIC_BUILD=OFF',
+	'Dev': '--preset=experimental -D CMAKE_BUILD_TYPE=Debug -D VNC=OFF -D STATIC_BUILD=OFF'
 ]

 def gitClone(repository, branch) {
--- a/.ci/build.sh
+++ b/.ci/build.sh
@@ -662,7 +662,7 @@ fi
 if [ ! -e "discord_game_sdk.zip" ]
 then
 	echo [-] Downloading Discord Game SDK
-	wget -qO discord_game_sdk.zip "https://dl-game-sdk.discordapp.net/2.5.6/discord_game_sdk.zip"
+	wget -qO discord_game_sdk.zip "https://dl-game-sdk.discordapp.net/latest/discord_game_sdk.zip"
 	status=$?
 	if [ $status -ne 0 ]
 	then
@@ -673,9 +673,10 @@ fi

 # Determine Discord Game SDK architecture.
 case $arch in
-	32)	arch_discord="x86";;
-	64)	arch_discord="x86_64";;
-	*)	arch_discord="$arch";;
+	32)		arch_discord="x86";;
+	64)		arch_discord="x86_64";;
+	arm64 | ARM64)	arch_discord="aarch64";;
+	*)		arch_discord="$arch";;
 esac

 # Create temporary directory for archival.
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -35,7 +35,7 @@ if(MUNT_EXTERNAL)
 endif()

 project(86Box
-    VERSION 3.5
+    VERSION 3.6
    DESCRIPTION "Emulator of x86-based systems"
    HOMEPAGE_URL "https://86box.net"
    LANGUAGES C CXX)
@@ -187,11 +187,10 @@ elseif(BUILD_TYPE_LOWER STREQUAL "alpha")
    add_compile_definitions(ALPHA_BUILD)
 endif()

-# Variables introduced by richardg867 for versioning stuff
+# Versioning variables
 if(NOT CMAKE_PROJECT_VERSION_PATCH)
    set(CMAKE_PROJECT_VERSION_PATCH 0)
 endif()
-set(EMU_VERSION_EX "3.50")
 if(NOT EMU_BUILD_NUM)
    set(EMU_BUILD_NUM 0)
 endif()
--- a/bumpversion.sh
+++ b/bumpversion.sh
@@ -17,44 +17,34 @@

 # Parse arguments.
 newversion="$1"
-if [ -z "$(echo $newversion | grep '\.')" ]
+romversion="$2"
+if [ -z "$(echo "$newversion" | grep '\.')" ]
 then
-	echo '[!] Usage: bumpversion.sh x.y[.z]'
+	echo '[!] Usage: bumpversion.sh x.y[.z] [romversion]'
 	exit 1
 fi
 shift

 # Extract version components.
-newversion_maj=$(echo $newversion | cut -d. -f1)
-newversion_min=$(echo $newversion | cut -d. -f2)
-newversion_patch=$(echo $newversion | cut -d. -f3)
+newversion_maj=$(echo "$newversion" | cut -d. -f1)
+newversion_min=$(echo "$newversion" | cut -d. -f2)
+newversion_patch=$(echo "$newversion" | cut -d. -f3)
 [ -z "$newversion_patch" ] && newversion_patch=0

-base36() {
-	if [ $1 -lt 10 ]
-	then
-		echo $1
-	else
-		printf '%b' $(printf '\\%03o' $((55 + $1)))
-	fi
-}
-newversion_maj_base36=$(base36 $newversion_maj)
-newversion_min_base36=$(base36 $newversion_min)
-newversion_patch_base36=$(base36 $newversion_patch)
+
+if [ -z "${romversion}" ]; then
+	# Get the latest ROM release from the GitHub API.
+	romversion=$(curl --silent "https://api.github.com/repos/86Box/roms/releases/latest" |
+		grep '"tag_name":' |
+		sed -E 's/.*"([^"]+)".*/\1/')
+fi

 # Switch to the repository root directory.
-cd "$(dirname "$0")"
-
-get_latest_rom_release() {
-    # get the latest ROM release from GitHub api
-    curl --silent "https://api.github.com/repos/86Box/roms/releases/latest" |
-        grep '"tag_name":' |
-        sed -E 's/.*"([^"]+)".*/\1/'
-}
+cd "$(dirname "$0")" || exit

 pretty_date() {
-    # Ensure we get the date in English
-    LANG=en_US.UTF-8 date '+%a %b %d %Y'
+	# Ensure we get the date in English.
+	LANG=en_US.UTF-8 date '+%a %b %d %Y'
 }

 # Patch files.
@@ -71,17 +61,15 @@ patch_file() {
 	fi
 }
 patch_file CMakeLists.txt VERSION 's/^(\s*VERSION ).+/\1'"$newversion"'/'
-patch_file CMakeLists.txt EMU_VERSION_EX 's/(\s*set\(EMU_VERSION_EX\s+")[^"]+/\1'"$newversion_maj_base36.$newversion_min_base36$newversion_patch_base36"'/'
 patch_file vcpkg.json version-string 's/(^\s*"version-string"\s*:\s*")[^"]+/\1'"$newversion"'/'
 patch_file src/include_make/*/version.h EMU_VERSION 's/(#\s*define\s+EMU_VERSION\s+")[^"]+/\1'"$newversion"'/'
-patch_file src/include_make/*/version.h EMU_VERSION_EX 's/(#\s*define\s+EMU_VERSION_EX\s+")[^"]+/\1'"$newversion_maj_base36.$newversion_min_base36$newversion_patch_base36"'/'
 patch_file src/include_make/*/version.h EMU_VERSION_MAJ 's/(#\s*define\s+EMU_VERSION_MAJ\s+)[0-9]+/\1'"$newversion_maj"'/'
 patch_file src/include_make/*/version.h EMU_VERSION_MIN 's/(#\s*define\s+EMU_VERSION_MIN\s+)[0-9]+/\1'"$newversion_min"'/'
 patch_file src/include_make/*/version.h EMU_VERSION_PATCH 's/(#\s*define\s+EMU_VERSION_PATCH\s+)[0-9]+/\1'"$newversion_patch"'/'
 patch_file src/include_make/*/version.h COPYRIGHT_YEAR 's/(#\s*define\s+COPYRIGHT_YEAR\s+)[0-9]+/\1'"$(date +%Y)"'/'
 patch_file src/include_make/*/version.h EMU_DOCS_URL 's/(#\s*define\s+EMU_DOCS_URL\s+"https:\/\/[^\/]+\/en\/v)[^\/]+/\1'"$newversion_maj.$newversion_min"'/'
 patch_file src/unix/assets/*.spec Version 's/(Version:\s+)[0-9].+/\1'"$newversion"'/'
-patch_file src/unix/assets/*.spec '%global romver' 's/(^%global\ romver\s+)[0-9]{8}/'"$(get_latest_rom_release)"'/'
+patch_file src/unix/assets/*.spec '%global romver' 's/(^%global\ romver\s+)[0-9]{8}/\1'"$romversion"'/'
 patch_file src/unix/assets/*.spec 'changelog version' 's/(^[*]\s.*>\s+)[0-9].+/\1'"$newversion"-1'/'
 patch_file src/unix/assets/*.spec 'changelog date' 's/(^[*]\s)[a-zA-Z]{3}\s[a-zA-Z]{3}\s[0-9]{2}\s[0-9]{4}/\1'"$(pretty_date)"'/'
 patch_file src/unix/assets/*.metainfo.xml release 's/(<release version=")[^"]+(" date=")[^"]+/\1'"$newversion"'\2'"$(date +%Y-%m-%d)"'/'
--- a/src/86box.c
+++ b/src/86box.c
@@ -172,6 +172,7 @@ int GUS = 0;					/* (C) sound option */
 int SSI2001 = 0;				/* (C) sound option */
 int voodoo_enabled = 0;				/* (C) video option */
 int ibm8514_enabled = 0;			/* (C) video option */
+int xga_enabled = 0;			/* (C) video option */
 uint32_t mem_size = 0;				/* (C) memory size (Installed on system board)*/
 uint32_t isa_mem_size = 0;	/* (C) memory size (ISA Memory Cards) */
 int	cpu_use_dynarec = 0;			/* (C) cpu uses/needs Dyna */
--- a/src/config.c
+++ b/src/config.c
@@ -931,6 +931,7 @@ load_video(void)

    voodoo_enabled = !!config_get_int(cat, "voodoo", 0);
    ibm8514_enabled = !!config_get_int(cat, "8514a", 0);
+    xga_enabled = !!config_get_int(cat, "xga", 0);
 }


@@ -2474,6 +2475,11 @@ save_video(void)
      else
 	config_set_int(cat, "8514a", ibm8514_enabled);

+    if (xga_enabled == 0)
+	config_delete_var(cat, "xga");
+      else
+	config_set_int(cat, "xga", xga_enabled);
+
    delete_section_if_empty(cat);
 }

--- a/src/cpu/x86.c
+++ b/src/cpu/x86.c
@@ -343,7 +343,7 @@ softresetx86(void)
    if (soft_reset_mask)
 	return;

-    if (ibm8514_enabled)
+    if (ibm8514_enabled || xga_enabled)
        vga_on = 1;

    reset_common(0);
--- a/src/cpu/x87_ops.h
+++ b/src/cpu/x87_ops.h
@@ -387,9 +387,9 @@ static __inline uint16_t x87_ucompare(double a, double b)
 #if !defined(_MSC_VER) || defined(__clang__)
        /* Memory barrier, to force GCC to write to the input parameters
         * before the compare rather than after */
-        asm volatile ("" : : : "memory");
+        __asm volatile ("" : : : "memory");

-        asm(
+        __asm(
                "fldl %2\n"
                "fldl %1\n"
                "fclex\n"
--- a/src/gdbstub.c
+++ b/src/gdbstub.c
@@ -43,7 +43,7 @@

 #define FAST_RESPONSE(s)         \
    strcpy(client->response, s); \
-    client->response_pos = sizeof(s);
+    client->response_pos = sizeof(s) - 1;
 #define FAST_RESPONSE_HEX(s) gdbstub_client_respond_hex(client, (uint8_t *) s, sizeof(s));

 enum {
@@ -118,7 +118,7 @@ typedef struct _gdbstub_client_ {

    event_t *processed_event, *response_event;

-    uint16_t last_io_base, last_io_len;
+    uint16_t last_io_base, last_io_len, last_io_value;

    struct _gdbstub_client_ *next;
 } gdbstub_client_t;
@@ -155,20 +155,23 @@ gdbstub_log(const char *fmt, ...)
 static x86seg    *segment_regs[] = { &cpu_state.seg_cs, &cpu_state.seg_ss, &cpu_state.seg_ds, &cpu_state.seg_es, &cpu_state.seg_fs, &cpu_state.seg_gs };
 static uint32_t  *cr_regs[]      = { &cpu_state.CR0.l, &cr2, &cr3, &cr4 };
 static void      *fpu_regs[]     = { &cpu_state.npxc, &cpu_state.npxs, NULL, &x87_pc_seg, &x87_pc_off, &x87_op_seg, &x87_op_off };
-static const char target_xml[]   = /* based on qemu's i386-32bit.xml */
+static const char target_xml[]   = /* QEMU gdb-xml/i386-32bit.xml with modifications (described in comments) */
    // clang-format off
    "<?xml version=\"1.0\"?>"
    "<!DOCTYPE target SYSTEM \"gdb-target.dtd\">"
    "<target>"
-        "<architecture>i8086</architecture>"
+        "<architecture>i8086</architecture>" /* start in 16-bit mode to work around known GDB bug preventing 32->16 switching */
+        ""
        "<feature name=\"org.gnu.gdb.i386.core\">"
            "<flags id=\"i386_eflags\" size=\"4\">"
+                "<field name=\"\" start=\"22\" end=\"31\"/>"
                "<field name=\"ID\" start=\"21\" end=\"21\"/>"
                "<field name=\"VIP\" start=\"20\" end=\"20\"/>"
                "<field name=\"VIF\" start=\"19\" end=\"19\"/>"
                "<field name=\"AC\" start=\"18\" end=\"18\"/>"
                "<field name=\"VM\" start=\"17\" end=\"17\"/>"
                "<field name=\"RF\" start=\"16\" end=\"16\"/>"
+                "<field name=\"\" start=\"15\" end=\"15\"/>"
                "<field name=\"NT\" start=\"14\" end=\"14\"/>"
                "<field name=\"IOPL\" start=\"12\" end=\"13\"/>"
                "<field name=\"OF\" start=\"11\" end=\"11\"/>"
@@ -177,12 +180,14 @@ static const char target_xml[]   = /* based on qemu's i386-32bit.xml */
                "<field name=\"TF\" start=\"8\" end=\"8\"/>"
                "<field name=\"SF\" start=\"7\" end=\"7\"/>"
                "<field name=\"ZF\" start=\"6\" end=\"6\"/>"
+                "<field name=\"\" start=\"5\" end=\"5\"/>"
                "<field name=\"AF\" start=\"4\" end=\"4\"/>"
                "<field name=\"PF\" start=\"2\" end=\"2\"/>"
+                "<field name=\"\" start=\"1\" end=\"1\"/>"
                "<field name=\"CF\" start=\"0\" end=\"0\"/>"
            "</flags>"
            ""
-            "<reg name=\"eax\" bitsize=\"32\" type=\"int32\"/>"
+            "<reg name=\"eax\" bitsize=\"32\" type=\"int32\" regnum=\"0\"/>"
            "<reg name=\"ecx\" bitsize=\"32\" type=\"int32\"/>"
            "<reg name=\"edx\" bitsize=\"32\" type=\"int32\"/>"
            "<reg name=\"ebx\" bitsize=\"32\" type=\"int32\"/>"
@@ -190,6 +195,7 @@ static const char target_xml[]   = /* based on qemu's i386-32bit.xml */
            "<reg name=\"ebp\" bitsize=\"32\" type=\"data_ptr\"/>"
            "<reg name=\"esi\" bitsize=\"32\" type=\"int32\"/>"
            "<reg name=\"edi\" bitsize=\"32\" type=\"int32\"/>"
+            ""
            "<reg name=\"eip\" bitsize=\"32\" type=\"code_ptr\"/>"
            "<reg name=\"eflags\" bitsize=\"32\" type=\"i386_eflags\"/>"
            ""
@@ -200,9 +206,6 @@ static const char target_xml[]   = /* based on qemu's i386-32bit.xml */
            "<reg name=\"fs\" bitsize=\"16\" type=\"int32\"/>"
            "<reg name=\"gs\" bitsize=\"16\" type=\"int32\"/>"
            ""
-            "<reg name=\"fs_base\" bitsize=\"32\" type=\"int32\"/>"
-            "<reg name=\"gs_base\" bitsize=\"32\" type=\"int32\"/>"
-            ""
            "<flags id=\"i386_cr0\" size=\"4\">"
                "<field name=\"PG\" start=\"31\" end=\"31\"/>"
                "<field name=\"CD\" start=\"30\" end=\"30\"/>"
@@ -363,7 +366,7 @@ gdbstub_hex_encode(int c)
    if (c < 10)
        return c + '0';
    else
-        return c - 10 + 'A';
+        return c - 10 + 'a';
 }

 static int
@@ -564,13 +567,21 @@ gdbstub_client_write_reg(int index, uint8_t *buf)

        case GDB_REG_MM0 ... GDB_REG_MM7:
            width                               = 8;
-            cpu_state.MM[index - GDB_REG_MM0].q = *((uint64_t *) &buf);
+            cpu_state.MM[index - GDB_REG_MM0].q = *((uint64_t *) buf);
            break;

        default:
            width = 0;
    }

+#ifdef ENABLE_GDBSTUB_LOG
+    char logbuf[256], *p = logbuf + sprintf(logbuf, "GDB Stub: Setting register %d to ", index);
+    for (int i = width - 1; i >= 0; i--)
+        p += sprintf(p, "%02X", buf[i]);
+    sprintf(p, "\n");
+    gdbstub_log(logbuf);
+#endif
+
    return width;
 }

@@ -681,8 +692,8 @@ gdbstub_client_read_reg(int index, uint8_t *buf)
            break;

        case GDB_REG_MM0 ... GDB_REG_MM7:
-            width                               = 8;
-            cpu_state.MM[index - GDB_REG_MM0].q = *((uint64_t *) &buf);
+            width               = 8;
+            *((uint64_t *) buf) = cpu_state.MM[index - GDB_REG_MM0].q;
            break;

        default:
@@ -735,7 +746,7 @@ gdbstub_client_packet(gdbstub_client_t *client)
    send(client->socket, "+", 1, 0);

    /* Block other responses from being written while this one (if any is produced) isn't acknowledged. */
-    if ((client->packet[0] != 'c') && (client->packet[0] != 's')) {
+    if ((client->packet[0] != 'c') && (client->packet[0] != 's') && (client->packet[0] != 'v')) {
        thread_wait_event(client->response_event, -1);
        thread_reset_event(client->response_event);
    }
@@ -783,11 +794,15 @@ ok:
        case 'G': /* write all registers */
            /* Write the values of all registers. */
            for (i = 0; i < GDB_REG_MAX; i++) {
+                if (i == GDB_REG_MAX)
+                    goto e22;
                if (!gdbstub_client_read_hex(client, buf, sizeof(buf)))
                    break;
-                client->packet_pos += gdbstub_client_write_reg(i, buf);
+                client->packet_pos += gdbstub_client_write_reg(i, buf) << 1;
            }
-            break;
+
+            /* Respond positively. */
+            goto ok;

        case 'H': /* set thread */
            /* Read operation type and thread ID. */
@@ -1016,6 +1031,10 @@ e00:
                        break;
                    }
                }
+            } else if (!strncmp(client->response, "Attached", 8)) {
+                FAST_RESPONSE("1");
+            } else if (!strcmp(client->response, "C")) {
+                FAST_RESPONSE("QC1");
            } else if (!strcmp(client->response, "Rcmd")) {
                /* Read and decode command in-place. */
                i                 = gdbstub_client_read_hex(client, (uint8_t *) client->packet, strlen(client->packet) - client->packet_pos);
@@ -1027,19 +1046,24 @@ e00:
                p = strtok_r(client->packet, " ", &strtok_save);
                if (!p)
                    goto ok;
+                i = strlen(p) - 1; /* get last character offset */

                /* Interpret the command. */
                if (p[0] == 'i') {
                    /* Read I/O operation width. */
-                    l = (p[1] == 'n') ? p[2] : p[1];
+                    l = (i < 1) ? '\0' : p[i];

                    /* Read optional I/O port. */
                    if (!(p = strtok_r(NULL, " ", &strtok_save)) || !gdbstub_num_decode(p, &j, GDB_MODE_HEX) || (j < 0) || (j >= 65536))
                        j = client->last_io_base;
+                    else
+                        client->last_io_base = j;

                    /* Read optional length. */
                    if (!(p = strtok_r(NULL, " ", &strtok_save)) || !gdbstub_num_decode(p, &k, GDB_MODE_BASE10))
                        k = client->last_io_len;
+                    else
+                        client->last_io_len = k;

                    /* Clamp length. */
                    if (k < 1)
@@ -1091,6 +1115,57 @@ e00:
                    client->response_pos = 0;
                    gdbstub_client_respond_hex(client, (uint8_t *) &client->packet, client->packet_pos);
                    break;
+                } else if (p[0] == 'o') {
+                    /* Read I/O operation width. */
+                    l = (i < 1) ? '\0' : p[i];
+
+                    /* Read optional I/O port. */
+                    if (!(p = strtok_r(NULL, " ", &strtok_save)) || !gdbstub_num_decode(p, &j, GDB_MODE_HEX) || (j < 0) || (j >= 65536))
+                        j = -1;
+
+                    /* Read optional value. */
+                    if (!(p = strtok_r(NULL, " ", &strtok_save)) || !gdbstub_num_decode(p, &k, GDB_MODE_HEX)) {
+                        if (j == -1)
+                            k = client->last_io_value;
+                        else
+                            k = j; /* only one specified = treat as value on last port */
+                        j = -1;
+                    }
+                    if (j == -1)
+                        j = client->last_io_base;
+                    else
+                        client->last_io_base = j;
+                    client->last_io_value = k;
+
+                    /* Write port. */
+                    switch (l) {
+                        case 'd':
+                        case 'l':
+                            outl(j, k);
+                            break;
+
+                        case 'w':
+                            outw(j, k);
+                            break;
+
+                        case 'b':
+                        case 't':
+                        case '\0':
+                            outb(j, k);
+                            break;
+
+                        default:
+                            goto unknown;
+                    }
+                } else if (p[0] == 'r') {
+                    pc_reset_hard();
+                } else if ((p[0] == '?') || !strcmp(p, "help")) {
+                    FAST_RESPONSE_HEX(
+                        "Commands:\n"
+                        "- ib/iw/il [port [length]] - Read {length} (default 1) I/O ports starting from {port} (default last)\n"
+                        "- ob/ow/ol [[port] value] - Write {value} to I/O {port} (both default last)\n"
+                        "- r - Hard reset the emulated machine\n");
+                    break;
                } else {
 unknown:
                    FAST_RESPONSE_HEX("Unknown command\n");
@@ -1103,7 +1178,6 @@ unknown:

        case 'z': /* remove break/watchpoint */
        case 'Z': /* insert break/watchpoint */
-        {
            gdbstub_breakpoint_t *breakpoint, *prev_breakpoint = NULL, **first_breakpoint;

            /* Parse breakpoint type. */
@@ -1225,7 +1299,6 @@ unknown:

            /* Respond positively. */
            goto ok;
-        }
    }
 end:
    /* Send response. */
@@ -1268,7 +1341,7 @@ gdbstub_cpu_exec(int cycs)
    /* Populate stop reason if we have stopped. */
    stop_reason_len = 0;
    if (gdbstub_step > GDBSTUB_EXEC) {
-        /* Assemble stop reason manually (avoiding sprintf and friends) for performance. */
+        /* Assemble stop reason manually, avoiding sprintf and friends for performance. */
        stop_reason[stop_reason_len++] = 'T';
        stop_reason[stop_reason_len++] = '0';
        stop_reason[stop_reason_len++] = '0' + ((gdbstub_step == GDBSTUB_BREAK) ? GDB_SIGINT : GDB_SIGTRAP);
@@ -1659,11 +1732,13 @@ gdbstub_init()
        .sin_port   = htons(port)
    };
    if (bind(gdbstub_socket, (struct sockaddr *) &bind_addr, sizeof(bind_addr)) == -1) {
+        pclog("GDB Stub: Failed to bind on port %d (%d)\n", port,
 #ifdef _WIN32
-        pclog("GDB Stub: Failed to bind on port %d (%d)\n", port, WSAGetLastError());
-#else 
-        pclog("GDB Stup: Failed to bind on port %d (%d)\n", port, errno);
+              WSAGetLastError()
+#else
+              errno
 #endif
+        );
        gdbstub_socket = -1;
        return;
    }
--- a/src/include/86box/86box.h
+++ b/src/include/86box/86box.h
@@ -112,7 +112,8 @@ extern int	sound_is_float,			/* (C) sound uses FP values */
 		GUS, GUSMAX,			/* (C) sound option */
 		SSI2001,			/* (C) sound option */
 		voodoo_enabled,			/* (C) video option */
-		ibm8514_enabled;        /* (C) video option */
+		ibm8514_enabled,        /* (C) video option */
+		xga_enabled;            /* (C) video option */
 extern uint32_t	mem_size;			/* (C) memory size (Installed on system board) */
 extern uint32_t	isa_mem_size;		/* (C) memory size (ISA Memory Cards) */
 extern int	cpu,				/* (C) cpu type */
--- a/src/include/86box/resource.h
+++ b/src/include/86box/resource.h
@@ -18,6 +18,7 @@
 *		Copyright 2008-2019 Sarah Walker.
 *		Copyright 2016-2019 Miran Grca.
 *		Copyright 2018,2019 David Hrdlička.
+ *		Copyright 2021-2022 Jasmine Iwanek.
 */

 #ifndef WIN_RESOURCE_H
@@ -184,6 +185,8 @@
 #define IDC_CHECK_VOODOO	1022
 #define IDC_BUTTON_VOODOO	1023
 #define IDC_CHECK_IBM8514	1024
+#define IDC_CHECK_XGA		1025
+#define IDC_BUTTON_XGA		1026

 #define IDC_INPUT		1030	/* input config */
 #define IDC_COMBO_MOUSE		1031
--- a/src/include/86box/version.h.in
+++ b/src/include/86box/version.h.in
@@ -22,7 +22,7 @@

 #define EMU_VERSION	"@CMAKE_PROJECT_VERSION@"
 #define EMU_VERSION_W	LSTR(EMU_VERSION)
-#define EMU_VERSION_EX	"@EMU_VERSION_EX@"
+#define EMU_VERSION_EX	"3.50" /* frozen due to IDE re-detection behavior on Windows */
 #define EMU_VERSION_MAJ	@CMAKE_PROJECT_VERSION_MAJOR@
 #define EMU_VERSION_MIN	@CMAKE_PROJECT_VERSION_MINOR@
 #define EMU_VERSION_PATCH @CMAKE_PROJECT_VERSION_PATCH@
--- a/src/include/86box/vid_8514a.h
+++ b/src/include/86box/vid_8514a.h
@@ -63,8 +63,9 @@ typedef struct ibm8514_t
        int sys_cnt, sys_cnt2;
        int temp_cnt;
        int16_t cx, cy;
-        int sx, sy;
-        int dx, dy;
+        int16_t sx, sy;
+        int16_t dx, dy;
+        int16_t err;
        uint32_t src, dest;
        uint32_t newsrc_blt, newdest_blt;
        uint32_t newdest_in, newdest_out;
--- a/src/include/86box/vid_ega.h
+++ b/src/include/86box/vid_ega.h
@@ -65,6 +65,9 @@ typedef struct ega_t {

    double clock;

+	int remap_required;
+	uint32_t (*remap_func)(struct ega_t *ega, uint32_t in_addr);
+
    void (*render)(struct ega_t *svga);

    void *eeprom;
@@ -94,6 +97,7 @@ extern int update_overscan;
 #if defined(EMU_MEM_H) && defined(EMU_ROM_H)
 extern void	ega_init(ega_t *ega, int monitor_type, int is_mono);
 extern void	ega_recalctimings(struct ega_t *ega);
+extern void ega_recalc_remap_func(struct ega_t *ega);
 #endif

 extern void	ega_out(uint16_t addr, uint8_t val, void *p);
--- a/src/include/86box/vid_ega_render_remap.h
+++ b/src/include/86box/vid_ega_render_remap.h
@@ -0,0 +1,111 @@
+#ifndef VIDEO_EGA_RENDER_REMAP_H
+# define VIDEO_EGA_RENDER_REMAP_H
+
+#define VAR_BYTE_MODE      (0 << 0)
+#define VAR_WORD_MODE_MA13 (1 << 0)
+#define VAR_WORD_MODE_MA15 (2 << 0)
+#define VAR_DWORD_MODE     (3 << 0)
+#define VAR_MODE_MASK      (3 << 0)
+#define VAR_ROW0_MA13      (1 << 2)
+#define VAR_ROW1_MA14      (1 << 3)
+
+#define ADDRESS_REMAP_FUNC(nr) \
+        static uint32_t address_remap_func_ ## nr(ega_t *ega, uint32_t in_addr) \
+        {                                                                       \
+                uint32_t out_addr;                                              \
+                                                                                \
+                switch (nr & VAR_MODE_MASK)                                     \
+                {                                                               \
+                        case VAR_BYTE_MODE:                                     \
+                        out_addr = in_addr;                                     \
+                        break;                                                  \
+                                                                                \
+                        case VAR_WORD_MODE_MA13:                                \
+                        out_addr = ((in_addr << 1) & 0x1fff8) |                 \
+                                   ((in_addr >> 13) & 0x4) |                    \
+                                   (in_addr & ~0x1ffff);                        \
+                        break;                                                  \
+                                                                                \
+                        case VAR_WORD_MODE_MA15:                                \
+                        out_addr = ((in_addr << 1) & 0x1fff8) |                 \
+                                   ((in_addr >> 15) & 0x4) |                    \
+                                   (in_addr & ~0x1ffff);                        \
+                        break;                                                  \
+                                                                                \
+                        case VAR_DWORD_MODE:                                    \
+                        out_addr = ((in_addr << 2) & 0x3fff0) |                 \
+                                   ((in_addr >> 14) & 0xc) |                    \
+                                   (in_addr & ~0x3ffff);                        \
+                        break;                                                  \
+                }                                                               \
+																				\
+                if (nr & VAR_ROW0_MA13)                                         \
+                        out_addr = (out_addr & ~0x8000) |                \
+                                   ((ega->sc & 1) ? 0x8000 : 0);        \
+                if (nr & VAR_ROW1_MA14)                                         \
+                        out_addr = (out_addr & ~0x10000) |                \
+                                   ((ega->sc & 2) ? 0x10000 : 0);        \
+                                                                                \
+                return out_addr;                                                \
+        }
+
+ADDRESS_REMAP_FUNC(0)
+ADDRESS_REMAP_FUNC(1)
+ADDRESS_REMAP_FUNC(2)
+ADDRESS_REMAP_FUNC(3)
+ADDRESS_REMAP_FUNC(4)
+ADDRESS_REMAP_FUNC(5)
+ADDRESS_REMAP_FUNC(6)
+ADDRESS_REMAP_FUNC(7)
+ADDRESS_REMAP_FUNC(8)
+ADDRESS_REMAP_FUNC(9)
+ADDRESS_REMAP_FUNC(10)
+ADDRESS_REMAP_FUNC(11)
+ADDRESS_REMAP_FUNC(12)
+ADDRESS_REMAP_FUNC(13)
+ADDRESS_REMAP_FUNC(14)
+ADDRESS_REMAP_FUNC(15)
+
+static uint32_t (*address_remap_funcs[16])(ega_t *ega, uint32_t in_addr) =
+{
+        address_remap_func_0,
+        address_remap_func_1,
+        address_remap_func_2,
+        address_remap_func_3,
+        address_remap_func_4,
+        address_remap_func_5,
+        address_remap_func_6,
+        address_remap_func_7,
+        address_remap_func_8,
+        address_remap_func_9,
+        address_remap_func_10,
+        address_remap_func_11,
+        address_remap_func_12,
+        address_remap_func_13,
+        address_remap_func_14,
+        address_remap_func_15
+};
+
+void ega_recalc_remap_func(ega_t *ega)
+{
+        int func_nr;
+
+        if (ega->crtc[0x14] & 0x40)
+                func_nr = VAR_DWORD_MODE;
+        else if (ega->crtc[0x17] & 0x40)
+                func_nr = VAR_BYTE_MODE;
+        else if (ega->crtc[0x17] & 0x20)
+                func_nr = VAR_WORD_MODE_MA15;
+        else
+                func_nr = VAR_WORD_MODE_MA13;
+
+        if (!(ega->crtc[0x17] & 0x01))
+                func_nr |= VAR_ROW0_MA13;
+        if (!(ega->crtc[0x17] & 0x02))
+                func_nr |= VAR_ROW1_MA14;
+
+		ega->remap_required = (func_nr != 0);
+        ega->remap_func = address_remap_funcs[func_nr];
+}
+
+#endif /*VIDEO_RENDER_REMAP_H*/
--- a/src/include/86box/vid_svga.h
+++ b/src/include/86box/vid_svga.h
@@ -19,6 +19,7 @@

 #include <86box/thread.h>
 #include <86box/vid_8514a.h>
+#include <86box/vid_xga.h>

 #ifndef VIDEO_SVGA_H
 # define VIDEO_SVGA_H
@@ -49,6 +50,7 @@ typedef union {
 typedef struct svga_t
 {
    ibm8514_t dev8514;
+    xga_t xga;
    mem_mapping_t mapping;

    uint8_t fast, chain4, chain2_write, chain2_read,
@@ -171,12 +173,14 @@ typedef struct svga_t
    void *ramdac, *clock_gen;
 } svga_t;

-extern svga_t *svga_8514;
-extern int vga_on;
+extern int vga_on, ibm8514_on;

 extern void ibm8514_poll(ibm8514_t *dev, svga_t *svga);
 extern void ibm8514_recalctimings(svga_t *svga);

+extern void xga_poll(xga_t *xga, svga_t *svga);
+extern void xga_recalctimings(svga_t *svga);
+
 extern int	svga_init(const device_t *info, svga_t *svga, void *p, int memsize,
 			  void (*recalctimings_ex)(struct svga_t *svga),
 			  uint8_t (*video_in) (uint16_t addr, void *p),
--- a/src/include/86box/vid_xga.h
+++ b/src/include/86box/vid_xga.h
@@ -0,0 +1,164 @@
+/*
+ * 86Box	A hypervisor and IBM PC system emulator that specializes in
+ *		running old operating systems and software designed for IBM
+ *		PC systems and compatibles from 1981 through fairly recent
+ *		system designs based on the PCI bus.
+ *
+ *		This file is part of the 86Box distribution.
+ *
+ *		IBM XGA emulation.
+ *
+ *
+ *
+ * Authors:	TheCollector1995.
+ *
+ *		Copyright 2022 TheCollector1995.
+ */
+
+#ifndef VIDEO_XGA_H
+# define VIDEO_XGA_H
+
+#include <86box/rom.h>
+
+typedef struct {
+    int ena;
+    int x, y, xoff, yoff, xsize, ysize;
+    uint32_t addr;
+} xga_hwcursor_t;
+
+typedef struct xga_t
+{
+	mem_mapping_t memio_mapping;
+	mem_mapping_t linear_mapping;
+	mem_mapping_t video_mapping;
+	rom_t bios_rom;
+	xga_hwcursor_t hwcursor, hwcursor_latch;
+    PALETTE extpal;
+
+    uint8_t test, atest[2], testpixel;;
+    uint8_t pos_regs[8];
+    uint8_t disp_addr;
+    uint8_t cfg_reg;
+    uint8_t instance;
+    uint8_t op_mode;
+    uint8_t aperture_cntl;
+    uint8_t ap_idx;
+    uint8_t access_mode;
+    uint8_t regs[0x100];
+    uint8_t regs_idx;
+    uint8_t hwc_hotspot_x;
+    uint8_t hwc_hotspot_y;
+    uint8_t disp_cntl_1, disp_cntl_2;
+    uint8_t clk_sel_1, clk_sel_2;
+    uint8_t hwc_control;
+    uint8_t bus_arb;
+    uint8_t select_pos_isa;
+    uint8_t hwcursor_oddeven;
+    uint8_t cfg_reg_instance;
+    uint8_t rowcount;
+    uint8_t pal_idx, pal_idx_prefetch;
+    uint8_t pal_seq;
+    uint8_t pal_mask;
+    uint8_t pal_r, pal_r_prefetch;
+    uint8_t pal_g, pal_g_prefetch;
+    uint8_t pal_b, pal_b_prefetch;
+    uint8_t sprite_data[1024];
+    uint8_t scrollcache;
+    uint8_t direct_color;
+    uint8_t *vram, *changedvram;
+
+    int16_t hwc_pos_x;
+    int16_t hwc_pos_y;
+
+    uint16_t pos_idx;
+    uint16_t htotal;
+    uint16_t sprite_idx, sprite_idx_prefetch;
+    uint16_t hdisp;
+    uint16_t vtotal;
+    uint16_t vdispend;
+    uint16_t vblankstart;
+    uint16_t vsyncstart;
+    uint16_t linecmp;
+    uint16_t pix_map_width;
+    uint16_t sprite_pal_addr_idx, old_pal_addr_idx;
+    uint16_t sprite_pal_addr_idx_prefetch;
+
+    int v_total, dispend, v_syncstart, split, v_blankstart,
+        h_disp,  h_disp_old, h_total,  h_disp_time, rowoffset,
+        dispon, h_disp_on, vc, sc, linepos, oddeven, firstline, lastline,
+        firstline_draw, lastline_draw, displine, fullchange, interlace,
+        char_width, hwcursor_on;
+    int pal_pos, pal_pos_prefetch;
+    int on;
+    int op_mode_reset, linear_endian_reverse;
+    int sprite_pos, sprite_pos_prefetch, cursor_data_on;
+    int pal_test;
+    int type, bus;
+
+    uint32_t linear_base, linear_size, banked_mask;
+    uint32_t base_addr_1mb;
+    uint32_t hwc_color0, hwc_color1;
+    uint32_t disp_start_addr;
+    uint32_t ma_latch;
+    uint32_t vram_size;
+    uint32_t vram_mask;
+    uint32_t rom_addr;
+	uint32_t ma, maback;
+	uint32_t extpallook[256];
+	uint32_t read_bank, write_bank;
+	uint32_t px_map_base;
+
+    uint64_t dispontime, dispofftime;
+
+    struct
+    {
+        uint8_t control;
+        uint8_t px_map_idx;
+        uint8_t frgd_mix, bkgd_mix;
+        uint8_t cc_cond;
+        uint8_t octant;
+        uint8_t draw_mode;
+        uint8_t mask_mode;
+        uint8_t short_stroke_vector1;
+        uint8_t short_stroke_vector2;
+        uint8_t short_stroke_vector3;
+        uint8_t short_stroke_vector4;
+
+        int16_t bres_err_term;
+        int16_t bres_k1, bres_k2;
+
+        uint16_t blt_width;
+        uint16_t blt_height;
+        uint16_t mask_map_origin_x_off;
+        uint16_t mask_map_origin_y_off;
+        uint16_t src_map_x, src_map_y;
+        uint16_t dst_map_x, dst_map_y;
+        uint16_t pat_map_x, pat_map_y;
+
+        int ssv_state;
+        int pat_src;
+        int src_map;
+        int dst_map;
+        int bkgd_src;
+        int fore_src;
+        int x, y, sx, sy, dx, dy, px, py;
+        int pattern;
+        int command_len;
+
+        uint32_t short_stroke;
+        uint32_t color_cmp;
+        uint32_t carry_chain;
+        uint32_t plane_mask;
+        uint32_t frgd_color, bkgd_color;
+        uint32_t command;
+        uint32_t dir_cmd;
+
+        uint8_t px_map_format[4];
+        uint16_t px_map_width[4];
+        uint16_t px_map_height[4];
+        uint32_t px_map_base[4];
+    } accel;
+
+    volatile int force_busy;
+} xga_t;
+#endif	/*VIDEO_XGA_H*/
--- a/src/include/86box/vid_xga_device.h
+++ b/src/include/86box/vid_xga_device.h
@@ -0,0 +1,22 @@
+/*
+ * 86Box	A hypervisor and IBM PC system emulator that specializes in
+ *		running old operating systems and software designed for IBM
+ *		PC systems and compatibles from 1981 through fairly recent
+ *		system designs based on the PCI bus.
+ *
+ *		This file is part of the 86Box distribution.
+ *
+ *		IBM XGA emulation.
+ *
+ *
+ *
+ * Authors:	TheCollector1995.
+ *
+ *		Copyright 2022 TheCollector1995.
+ */
+
+#ifndef VIDEO_XGA_DEVICE_H
+# define VIDEO_XGA_DEVICE_H
+extern const device_t xga_device;
+extern const device_t xga_isa_device;
+#endif	/*VIDEO_XGA_DEVICE_H*/
--- a/src/include/86box/video.h
+++ b/src/include/86box/video.h
@@ -200,6 +200,9 @@ extern void	agpgart_set_gart(void *handle, uint32_t base);


 #ifdef EMU_DEVICE_H
+/* IBM XGA */
+extern void xga_device_add(void);
+
 /* IBM 8514/A and generic clones*/
 extern void ibm8514_device_add(void);

--- a/src/include/vulkan/vk_icd.h
+++ b/src/include/vulkan/vk_icd.h
@@ -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 querying 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
--- a/src/include/vulkan/vk_layer.h
+++ b/src/include/vulkan/vk_layer.h
@@ -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
--- a/src/include/vulkan/vk_platform.h
+++ b/src/include/vulkan/vk_platform.h
@@ -0,0 +1,84 @@
+//
+// File: vk_platform.h
+//
+/*
+** Copyright 2014-2022 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 is not 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
--- a/src/include/vulkan/vk_sdk_platform.h
+++ b/src/include/vulkan/vk_sdk_platform.h
@@ -0,0 +1,69 @@
+//
+// File: vk_sdk_platform.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 VK_SDK_PLATFORM_H
+#define VK_SDK_PLATFORM_H
+
+#if defined(_WIN32)
+#define NOMINMAX
+#ifndef __cplusplus
+#undef inline
+#define inline __inline
+#endif // __cplusplus
+
+#if (defined(_MSC_VER) && _MSC_VER < 1900 /*vs2015*/)
+// C99:
+// Microsoft didn't implement C99 in Visual Studio; but started adding it with
+// VS2013.  However, VS2013 still didn't have snprintf().  The following is a
+// work-around (Note: The _CRT_SECURE_NO_WARNINGS macro must be set in the
+// "CMakeLists.txt" file).
+// NOTE: This is fixed in Visual Studio 2015.
+#define snprintf _snprintf
+#endif
+
+#define strdup _strdup
+
+#endif // _WIN32
+
+// Check for noexcept support using clang, with fallback to Windows or GCC version numbers
+#ifndef NOEXCEPT
+#if defined(__clang__)
+#if __has_feature(cxx_noexcept)
+#define HAS_NOEXCEPT
+#endif
+#else
+#if defined(__GXX_EXPERIMENTAL_CXX0X__) && __GNUC__ * 10 + __GNUC_MINOR__ >= 46
+#define HAS_NOEXCEPT
+#else
+#if defined(_MSC_FULL_VER) && _MSC_FULL_VER >= 190023026 && defined(_HAS_EXCEPTIONS) && _HAS_EXCEPTIONS
+#define HAS_NOEXCEPT
+#endif
+#endif
+#endif
+
+#ifdef HAS_NOEXCEPT
+#define NOEXCEPT noexcept
+#else
+#define NOEXCEPT
+#endif
+#endif
+
+#endif  // VK_SDK_PLATFORM_H
--- a/src/include/vulkan/vulkan.h
+++ b/src/include/vulkan/vulkan.h
@@ -0,0 +1,92 @@
+#ifndef VULKAN_H_
+#define VULKAN_H_ 1
+
+/*
+** Copyright 2015-2022 The Khronos Group Inc.
+**
+** SPDX-License-Identifier: Apache-2.0
+*/
+
+#include "vk_platform.h"
+#include "vulkan_core.h"
+
+#ifdef VK_USE_PLATFORM_ANDROID_KHR
+#include "vulkan_android.h"
+#endif
+
+#ifdef VK_USE_PLATFORM_FUCHSIA
+#include <zircon/types.h>
+#include "vulkan_fuchsia.h"
+#endif
+
+#ifdef VK_USE_PLATFORM_IOS_MVK
+#include "vulkan_ios.h"
+#endif
+
+
+#ifdef VK_USE_PLATFORM_MACOS_MVK
+#include "vulkan_macos.h"
+#endif
+
+#ifdef VK_USE_PLATFORM_METAL_EXT
+#include "vulkan_metal.h"
+#endif
+
+#ifdef VK_USE_PLATFORM_VI_NN
+#include "vulkan_vi.h"
+#endif
+
+
+#ifdef VK_USE_PLATFORM_WAYLAND_KHR
+#include <wayland-client.h>
+#include "vulkan_wayland.h"
+#endif
+
+
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+#include <windows.h>
+#include "vulkan_win32.h"
+#endif
+
+
+#ifdef VK_USE_PLATFORM_XCB_KHR
+#include <xcb/xcb.h>
+#include "vulkan_xcb.h"
+#endif
+
+
+#ifdef VK_USE_PLATFORM_XLIB_KHR
+#include <X11/Xlib.h>
+#include "vulkan_xlib.h"
+#endif
+
+
+#ifdef VK_USE_PLATFORM_DIRECTFB_EXT
+#include <directfb.h>
+#include "vulkan_directfb.h"
+#endif
+
+
+#ifdef VK_USE_PLATFORM_XLIB_XRANDR_EXT
+#include <X11/Xlib.h>
+#include <X11/extensions/Xrandr.h>
+#include "vulkan_xlib_xrandr.h"
+#endif
+
+
+#ifdef VK_USE_PLATFORM_GGP
+#include <ggp_c/vulkan_types.h>
+#include "vulkan_ggp.h"
+#endif
+
+
+#ifdef VK_USE_PLATFORM_SCREEN_QNX
+#include <screen/screen.h>
+#include "vulkan_screen.h"
+#endif
+
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+#include "vulkan_beta.h"
+#endif
+
+#endif // VULKAN_H_
--- a/src/include/vulkan/vulkan.hpp
+++ b/src/include/vulkan/vulkan.hpp
--- a/src/include/vulkan/vulkan_android.h
+++ b/src/include/vulkan/vulkan_android.h
@@ -0,0 +1,125 @@
+#ifndef VULKAN_ANDROID_H_
+#define VULKAN_ANDROID_H_ 1
+
+/*
+** Copyright 2015-2022 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_android_surface 1
+struct ANativeWindow;
+#define VK_KHR_ANDROID_SURFACE_SPEC_VERSION 6
+#define VK_KHR_ANDROID_SURFACE_EXTENSION_NAME "VK_KHR_android_surface"
+typedef VkFlags VkAndroidSurfaceCreateFlagsKHR;
+typedef struct VkAndroidSurfaceCreateInfoKHR {
+    VkStructureType                   sType;
+    const void*                       pNext;
+    VkAndroidSurfaceCreateFlagsKHR    flags;
+    struct ANativeWindow*             window;
+} VkAndroidSurfaceCreateInfoKHR;
+
+typedef VkResult (VKAPI_PTR *PFN_vkCreateAndroidSurfaceKHR)(VkInstance instance, const VkAndroidSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR VkResult VKAPI_CALL vkCreateAndroidSurfaceKHR(
+    VkInstance                                  instance,
+    const VkAndroidSurfaceCreateInfoKHR*        pCreateInfo,
+    const VkAllocationCallbacks*                pAllocator,
+    VkSurfaceKHR*                               pSurface);
+#endif
+
+
+#define VK_ANDROID_external_memory_android_hardware_buffer 1
+struct AHardwareBuffer;
+#define VK_ANDROID_EXTERNAL_MEMORY_ANDROID_HARDWARE_BUFFER_SPEC_VERSION 5
+#define VK_ANDROID_EXTERNAL_MEMORY_ANDROID_HARDWARE_BUFFER_EXTENSION_NAME "VK_ANDROID_external_memory_android_hardware_buffer"
+typedef struct VkAndroidHardwareBufferUsageANDROID {
+    VkStructureType    sType;
+    void*              pNext;
+    uint64_t           androidHardwareBufferUsage;
+} VkAndroidHardwareBufferUsageANDROID;
+
+typedef struct VkAndroidHardwareBufferPropertiesANDROID {
+    VkStructureType    sType;
+    void*              pNext;
+    VkDeviceSize       allocationSize;
+    uint32_t           memoryTypeBits;
+} VkAndroidHardwareBufferPropertiesANDROID;
+
+typedef struct VkAndroidHardwareBufferFormatPropertiesANDROID {
+    VkStructureType                  sType;
+    void*                            pNext;
+    VkFormat                         format;
+    uint64_t                         externalFormat;
+    VkFormatFeatureFlags             formatFeatures;
+    VkComponentMapping               samplerYcbcrConversionComponents;
+    VkSamplerYcbcrModelConversion    suggestedYcbcrModel;
+    VkSamplerYcbcrRange              suggestedYcbcrRange;
+    VkChromaLocation                 suggestedXChromaOffset;
+    VkChromaLocation                 suggestedYChromaOffset;
+} VkAndroidHardwareBufferFormatPropertiesANDROID;
+
+typedef struct VkImportAndroidHardwareBufferInfoANDROID {
+    VkStructureType            sType;
+    const void*                pNext;
+    struct AHardwareBuffer*    buffer;
+} VkImportAndroidHardwareBufferInfoANDROID;
+
+typedef struct VkMemoryGetAndroidHardwareBufferInfoANDROID {
+    VkStructureType    sType;
+    const void*        pNext;
+    VkDeviceMemory     memory;
+} VkMemoryGetAndroidHardwareBufferInfoANDROID;
+
+typedef struct VkExternalFormatANDROID {
+    VkStructureType    sType;
+    void*              pNext;
+    uint64_t           externalFormat;
+} VkExternalFormatANDROID;
+
+typedef struct VkAndroidHardwareBufferFormatProperties2ANDROID {
+    VkStructureType                  sType;
+    void*                            pNext;
+    VkFormat                         format;
+    uint64_t                         externalFormat;
+    VkFormatFeatureFlags2            formatFeatures;
+    VkComponentMapping               samplerYcbcrConversionComponents;
+    VkSamplerYcbcrModelConversion    suggestedYcbcrModel;
+    VkSamplerYcbcrRange              suggestedYcbcrRange;
+    VkChromaLocation                 suggestedXChromaOffset;
+    VkChromaLocation                 suggestedYChromaOffset;
+} VkAndroidHardwareBufferFormatProperties2ANDROID;
+
+typedef VkResult (VKAPI_PTR *PFN_vkGetAndroidHardwareBufferPropertiesANDROID)(VkDevice device, const struct AHardwareBuffer* buffer, VkAndroidHardwareBufferPropertiesANDROID* pProperties);
+typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryAndroidHardwareBufferANDROID)(VkDevice device, const VkMemoryGetAndroidHardwareBufferInfoANDROID* pInfo, struct AHardwareBuffer** pBuffer);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR VkResult VKAPI_CALL vkGetAndroidHardwareBufferPropertiesANDROID(
+    VkDevice                                    device,
+    const struct AHardwareBuffer*               buffer,
+    VkAndroidHardwareBufferPropertiesANDROID*   pProperties);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryAndroidHardwareBufferANDROID(
+    VkDevice                                    device,
+    const VkMemoryGetAndroidHardwareBufferInfoANDROID* pInfo,
+    struct AHardwareBuffer**                    pBuffer);
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
--- a/src/include/vulkan/vulkan_beta.h
+++ b/src/include/vulkan/vulkan_beta.h
@@ -0,0 +1,994 @@
+#ifndef VULKAN_BETA_H_
+#define VULKAN_BETA_H_ 1
+
+/*
+** Copyright 2015-2022 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_video_queue 1
+VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkVideoSessionKHR)
+VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkVideoSessionParametersKHR)
+#define VK_KHR_VIDEO_QUEUE_SPEC_VERSION   4
+#define VK_KHR_VIDEO_QUEUE_EXTENSION_NAME "VK_KHR_video_queue"
+
+typedef enum VkQueryResultStatusKHR {
+    VK_QUERY_RESULT_STATUS_ERROR_KHR = -1,
+    VK_QUERY_RESULT_STATUS_NOT_READY_KHR = 0,
+    VK_QUERY_RESULT_STATUS_COMPLETE_KHR = 1,
+    VK_QUERY_RESULT_STATUS_MAX_ENUM_KHR = 0x7FFFFFFF
+} VkQueryResultStatusKHR;
+
+typedef enum VkVideoCodecOperationFlagBitsKHR {
+    VK_VIDEO_CODEC_OPERATION_INVALID_BIT_KHR = 0,
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+    VK_VIDEO_CODEC_OPERATION_ENCODE_H264_BIT_EXT = 0x00010000,
+#endif
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+    VK_VIDEO_CODEC_OPERATION_ENCODE_H265_BIT_EXT = 0x00020000,
+#endif
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+    VK_VIDEO_CODEC_OPERATION_DECODE_H264_BIT_EXT = 0x00000001,
+#endif
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+    VK_VIDEO_CODEC_OPERATION_DECODE_H265_BIT_EXT = 0x00000002,
+#endif
+    VK_VIDEO_CODEC_OPERATION_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF
+} VkVideoCodecOperationFlagBitsKHR;
+typedef VkFlags VkVideoCodecOperationFlagsKHR;
+
+typedef enum VkVideoChromaSubsamplingFlagBitsKHR {
+    VK_VIDEO_CHROMA_SUBSAMPLING_INVALID_BIT_KHR = 0,
+    VK_VIDEO_CHROMA_SUBSAMPLING_MONOCHROME_BIT_KHR = 0x00000001,
+    VK_VIDEO_CHROMA_SUBSAMPLING_420_BIT_KHR = 0x00000002,
+    VK_VIDEO_CHROMA_SUBSAMPLING_422_BIT_KHR = 0x00000004,
+    VK_VIDEO_CHROMA_SUBSAMPLING_444_BIT_KHR = 0x00000008,
+    VK_VIDEO_CHROMA_SUBSAMPLING_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF
+} VkVideoChromaSubsamplingFlagBitsKHR;
+typedef VkFlags VkVideoChromaSubsamplingFlagsKHR;
+
+typedef enum VkVideoComponentBitDepthFlagBitsKHR {
+    VK_VIDEO_COMPONENT_BIT_DEPTH_INVALID_KHR = 0,
+    VK_VIDEO_COMPONENT_BIT_DEPTH_8_BIT_KHR = 0x00000001,
+    VK_VIDEO_COMPONENT_BIT_DEPTH_10_BIT_KHR = 0x00000004,
+    VK_VIDEO_COMPONENT_BIT_DEPTH_12_BIT_KHR = 0x00000010,
+    VK_VIDEO_COMPONENT_BIT_DEPTH_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF
+} VkVideoComponentBitDepthFlagBitsKHR;
+typedef VkFlags VkVideoComponentBitDepthFlagsKHR;
+
+typedef enum VkVideoCapabilityFlagBitsKHR {
+    VK_VIDEO_CAPABILITY_PROTECTED_CONTENT_BIT_KHR = 0x00000001,
+    VK_VIDEO_CAPABILITY_SEPARATE_REFERENCE_IMAGES_BIT_KHR = 0x00000002,
+    VK_VIDEO_CAPABILITY_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF
+} VkVideoCapabilityFlagBitsKHR;
+typedef VkFlags VkVideoCapabilityFlagsKHR;
+
+typedef enum VkVideoSessionCreateFlagBitsKHR {
+    VK_VIDEO_SESSION_CREATE_DEFAULT_KHR = 0,
+    VK_VIDEO_SESSION_CREATE_PROTECTED_CONTENT_BIT_KHR = 0x00000001,
+    VK_VIDEO_SESSION_CREATE_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF
+} VkVideoSessionCreateFlagBitsKHR;
+typedef VkFlags VkVideoSessionCreateFlagsKHR;
+typedef VkFlags VkVideoBeginCodingFlagsKHR;
+typedef VkFlags VkVideoEndCodingFlagsKHR;
+
+typedef enum VkVideoCodingControlFlagBitsKHR {
+    VK_VIDEO_CODING_CONTROL_DEFAULT_KHR = 0,
+    VK_VIDEO_CODING_CONTROL_RESET_BIT_KHR = 0x00000001,
+    VK_VIDEO_CODING_CONTROL_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF
+} VkVideoCodingControlFlagBitsKHR;
+typedef VkFlags VkVideoCodingControlFlagsKHR;
+
+typedef enum VkVideoCodingQualityPresetFlagBitsKHR {
+    VK_VIDEO_CODING_QUALITY_PRESET_NORMAL_BIT_KHR = 0x00000001,
+    VK_VIDEO_CODING_QUALITY_PRESET_POWER_BIT_KHR = 0x00000002,
+    VK_VIDEO_CODING_QUALITY_PRESET_QUALITY_BIT_KHR = 0x00000004,
+    VK_VIDEO_CODING_QUALITY_PRESET_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF
+} VkVideoCodingQualityPresetFlagBitsKHR;
+typedef VkFlags VkVideoCodingQualityPresetFlagsKHR;
+typedef struct VkQueueFamilyQueryResultStatusProperties2KHR {
+    VkStructureType    sType;
+    void*              pNext;
+    VkBool32           queryResultStatusSupport;
+} VkQueueFamilyQueryResultStatusProperties2KHR;
+
+typedef struct VkVideoQueueFamilyProperties2KHR {
+    VkStructureType                  sType;
+    void*                            pNext;
+    VkVideoCodecOperationFlagsKHR    videoCodecOperations;
+} VkVideoQueueFamilyProperties2KHR;
+
+typedef struct VkVideoProfileKHR {
+    VkStructureType                     sType;
+    const void*                         pNext;
+    VkVideoCodecOperationFlagBitsKHR    videoCodecOperation;
+    VkVideoChromaSubsamplingFlagsKHR    chromaSubsampling;
+    VkVideoComponentBitDepthFlagsKHR    lumaBitDepth;
+    VkVideoComponentBitDepthFlagsKHR    chromaBitDepth;
+} VkVideoProfileKHR;
+
+typedef struct VkVideoProfilesKHR {
+    VkStructureType             sType;
+    const void*                 pNext;
+    uint32_t                    profileCount;
+    const VkVideoProfileKHR*    pProfiles;
+} VkVideoProfilesKHR;
+
+typedef struct VkVideoCapabilitiesKHR {
+    VkStructureType              sType;
+    void*                        pNext;
+    VkVideoCapabilityFlagsKHR    capabilityFlags;
+    VkDeviceSize                 minBitstreamBufferOffsetAlignment;
+    VkDeviceSize                 minBitstreamBufferSizeAlignment;
+    VkExtent2D                   videoPictureExtentGranularity;
+    VkExtent2D                   minExtent;
+    VkExtent2D                   maxExtent;
+    uint32_t                     maxReferencePicturesSlotsCount;
+    uint32_t                     maxReferencePicturesActiveCount;
+    VkExtensionProperties        stdHeaderVersion;
+} VkVideoCapabilitiesKHR;
+
+typedef struct VkPhysicalDeviceVideoFormatInfoKHR {
+     VkStructureType     sType;
+    void*                pNext;
+    VkImageUsageFlags    imageUsage;
+} VkPhysicalDeviceVideoFormatInfoKHR;
+
+typedef struct VkVideoFormatPropertiesKHR {
+    VkStructureType       sType;
+    void*                 pNext;
+    VkFormat              format;
+    VkComponentMapping    componentMapping;
+    VkImageCreateFlags    imageCreateFlags;
+    VkImageType           imageType;
+    VkImageTiling         imageTiling;
+    VkImageUsageFlags     imageUsageFlags;
+} VkVideoFormatPropertiesKHR;
+
+typedef struct VkVideoPictureResourceKHR {
+    VkStructureType    sType;
+    const void*        pNext;
+    VkOffset2D         codedOffset;
+    VkExtent2D         codedExtent;
+    uint32_t           baseArrayLayer;
+    VkImageView        imageViewBinding;
+} VkVideoPictureResourceKHR;
+
+typedef struct VkVideoReferenceSlotKHR {
+    VkStructureType                     sType;
+    const void*                         pNext;
+    int8_t                              slotIndex;
+    const VkVideoPictureResourceKHR*    pPictureResource;
+} VkVideoReferenceSlotKHR;
+
+typedef struct VkVideoGetMemoryPropertiesKHR {
+    VkStructureType           sType;
+    const void*               pNext;
+    uint32_t                  memoryBindIndex;
+    VkMemoryRequirements2*    pMemoryRequirements;
+} VkVideoGetMemoryPropertiesKHR;
+
+typedef struct VkVideoBindMemoryKHR {
+    VkStructureType    sType;
+    const void*        pNext;
+    uint32_t           memoryBindIndex;
+    VkDeviceMemory     memory;
+    VkDeviceSize       memoryOffset;
+    VkDeviceSize       memorySize;
+} VkVideoBindMemoryKHR;
+
+typedef struct VkVideoSessionCreateInfoKHR {
+    VkStructureType                 sType;
+    const void*                     pNext;
+    uint32_t                        queueFamilyIndex;
+    VkVideoSessionCreateFlagsKHR    flags;
+    const VkVideoProfileKHR*        pVideoProfile;
+    VkFormat                        pictureFormat;
+    VkExtent2D                      maxCodedExtent;
+    VkFormat                        referencePicturesFormat;
+    uint32_t                        maxReferencePicturesSlotsCount;
+    uint32_t                        maxReferencePicturesActiveCount;
+    const VkExtensionProperties*    pStdHeaderVersion;
+} VkVideoSessionCreateInfoKHR;
+
+typedef struct VkVideoSessionParametersCreateInfoKHR {
+    VkStructureType                sType;
+    const void*                    pNext;
+    VkVideoSessionParametersKHR    videoSessionParametersTemplate;
+    VkVideoSessionKHR              videoSession;
+} VkVideoSessionParametersCreateInfoKHR;
+
+typedef struct VkVideoSessionParametersUpdateInfoKHR {
+    VkStructureType    sType;
+    const void*        pNext;
+    uint32_t           updateSequenceCount;
+} VkVideoSessionParametersUpdateInfoKHR;
+
+typedef struct VkVideoBeginCodingInfoKHR {
+    VkStructureType                       sType;
+    const void*                           pNext;
+    VkVideoBeginCodingFlagsKHR            flags;
+    VkVideoCodingQualityPresetFlagsKHR    codecQualityPreset;
+    VkVideoSessionKHR                     videoSession;
+    VkVideoSessionParametersKHR           videoSessionParameters;
+    uint32_t                              referenceSlotCount;
+    const VkVideoReferenceSlotKHR*        pReferenceSlots;
+} VkVideoBeginCodingInfoKHR;
+
+typedef struct VkVideoEndCodingInfoKHR {
+    VkStructureType             sType;
+    const void*                 pNext;
+    VkVideoEndCodingFlagsKHR    flags;
+} VkVideoEndCodingInfoKHR;
+
+typedef struct VkVideoCodingControlInfoKHR {
+    VkStructureType                 sType;
+    const void*                     pNext;
+    VkVideoCodingControlFlagsKHR    flags;
+} VkVideoCodingControlInfoKHR;
+
+typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceVideoCapabilitiesKHR)(VkPhysicalDevice physicalDevice, const VkVideoProfileKHR* pVideoProfile, VkVideoCapabilitiesKHR* pCapabilities);
+typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceVideoFormatPropertiesKHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceVideoFormatInfoKHR* pVideoFormatInfo, uint32_t* pVideoFormatPropertyCount, VkVideoFormatPropertiesKHR* pVideoFormatProperties);
+typedef VkResult (VKAPI_PTR *PFN_vkCreateVideoSessionKHR)(VkDevice device, const VkVideoSessionCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkVideoSessionKHR* pVideoSession);
+typedef void (VKAPI_PTR *PFN_vkDestroyVideoSessionKHR)(VkDevice device, VkVideoSessionKHR videoSession, const VkAllocationCallbacks* pAllocator);
+typedef VkResult (VKAPI_PTR *PFN_vkGetVideoSessionMemoryRequirementsKHR)(VkDevice device, VkVideoSessionKHR videoSession, uint32_t* pVideoSessionMemoryRequirementsCount, VkVideoGetMemoryPropertiesKHR* pVideoSessionMemoryRequirements);
+typedef VkResult (VKAPI_PTR *PFN_vkBindVideoSessionMemoryKHR)(VkDevice device, VkVideoSessionKHR videoSession, uint32_t videoSessionBindMemoryCount, const VkVideoBindMemoryKHR* pVideoSessionBindMemories);
+typedef VkResult (VKAPI_PTR *PFN_vkCreateVideoSessionParametersKHR)(VkDevice device, const VkVideoSessionParametersCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkVideoSessionParametersKHR* pVideoSessionParameters);
+typedef VkResult (VKAPI_PTR *PFN_vkUpdateVideoSessionParametersKHR)(VkDevice device, VkVideoSessionParametersKHR videoSessionParameters, const VkVideoSessionParametersUpdateInfoKHR* pUpdateInfo);
+typedef void (VKAPI_PTR *PFN_vkDestroyVideoSessionParametersKHR)(VkDevice device, VkVideoSessionParametersKHR videoSessionParameters, const VkAllocationCallbacks* pAllocator);
+typedef void (VKAPI_PTR *PFN_vkCmdBeginVideoCodingKHR)(VkCommandBuffer commandBuffer, const VkVideoBeginCodingInfoKHR* pBeginInfo);
+typedef void (VKAPI_PTR *PFN_vkCmdEndVideoCodingKHR)(VkCommandBuffer commandBuffer, const VkVideoEndCodingInfoKHR* pEndCodingInfo);
+typedef void (VKAPI_PTR *PFN_vkCmdControlVideoCodingKHR)(VkCommandBuffer commandBuffer, const VkVideoCodingControlInfoKHR* pCodingControlInfo);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceVideoCapabilitiesKHR(
+    VkPhysicalDevice                            physicalDevice,
+    const VkVideoProfileKHR*                    pVideoProfile,
+    VkVideoCapabilitiesKHR*                     pCapabilities);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceVideoFormatPropertiesKHR(
+    VkPhysicalDevice                            physicalDevice,
+    const VkPhysicalDeviceVideoFormatInfoKHR*   pVideoFormatInfo,
+    uint32_t*                                   pVideoFormatPropertyCount,
+    VkVideoFormatPropertiesKHR*                 pVideoFormatProperties);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkCreateVideoSessionKHR(
+    VkDevice                                    device,
+    const VkVideoSessionCreateInfoKHR*          pCreateInfo,
+    const VkAllocationCallbacks*                pAllocator,
+    VkVideoSessionKHR*                          pVideoSession);
+
+VKAPI_ATTR void VKAPI_CALL vkDestroyVideoSessionKHR(
+    VkDevice                                    device,
+    VkVideoSessionKHR                           videoSession,
+    const VkAllocationCallbacks*                pAllocator);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkGetVideoSessionMemoryRequirementsKHR(
+    VkDevice                                    device,
+    VkVideoSessionKHR                           videoSession,
+    uint32_t*                                   pVideoSessionMemoryRequirementsCount,
+    VkVideoGetMemoryPropertiesKHR*              pVideoSessionMemoryRequirements);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkBindVideoSessionMemoryKHR(
+    VkDevice                                    device,
+    VkVideoSessionKHR                           videoSession,
+    uint32_t                                    videoSessionBindMemoryCount,
+    const VkVideoBindMemoryKHR*                 pVideoSessionBindMemories);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkCreateVideoSessionParametersKHR(
+    VkDevice                                    device,
+    const VkVideoSessionParametersCreateInfoKHR* pCreateInfo,
+    const VkAllocationCallbacks*                pAllocator,
+    VkVideoSessionParametersKHR*                pVideoSessionParameters);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkUpdateVideoSessionParametersKHR(
+    VkDevice                                    device,
+    VkVideoSessionParametersKHR                 videoSessionParameters,
+    const VkVideoSessionParametersUpdateInfoKHR* pUpdateInfo);
+
+VKAPI_ATTR void VKAPI_CALL vkDestroyVideoSessionParametersKHR(
+    VkDevice                                    device,
+    VkVideoSessionParametersKHR                 videoSessionParameters,
+    const VkAllocationCallbacks*                pAllocator);
+
+VKAPI_ATTR void VKAPI_CALL vkCmdBeginVideoCodingKHR(
+    VkCommandBuffer                             commandBuffer,
+    const VkVideoBeginCodingInfoKHR*            pBeginInfo);
+
+VKAPI_ATTR void VKAPI_CALL vkCmdEndVideoCodingKHR(
+    VkCommandBuffer                             commandBuffer,
+    const VkVideoEndCodingInfoKHR*              pEndCodingInfo);
+
+VKAPI_ATTR void VKAPI_CALL vkCmdControlVideoCodingKHR(
+    VkCommandBuffer                             commandBuffer,
+    const VkVideoCodingControlInfoKHR*          pCodingControlInfo);
+#endif
+
+
+#define VK_KHR_video_decode_queue 1
+#define VK_KHR_VIDEO_DECODE_QUEUE_SPEC_VERSION 4
+#define VK_KHR_VIDEO_DECODE_QUEUE_EXTENSION_NAME "VK_KHR_video_decode_queue"
+
+typedef enum VkVideoDecodeCapabilityFlagBitsKHR {
+    VK_VIDEO_DECODE_CAPABILITY_DEFAULT_KHR = 0,
+    VK_VIDEO_DECODE_CAPABILITY_DPB_AND_OUTPUT_COINCIDE_BIT_KHR = 0x00000001,
+    VK_VIDEO_DECODE_CAPABILITY_DPB_AND_OUTPUT_DISTINCT_BIT_KHR = 0x00000002,
+    VK_VIDEO_DECODE_CAPABILITY_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF
+} VkVideoDecodeCapabilityFlagBitsKHR;
+typedef VkFlags VkVideoDecodeCapabilityFlagsKHR;
+
+typedef enum VkVideoDecodeFlagBitsKHR {
+    VK_VIDEO_DECODE_DEFAULT_KHR = 0,
+    VK_VIDEO_DECODE_RESERVED_0_BIT_KHR = 0x00000001,
+    VK_VIDEO_DECODE_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF
+} VkVideoDecodeFlagBitsKHR;
+typedef VkFlags VkVideoDecodeFlagsKHR;
+typedef struct VkVideoDecodeCapabilitiesKHR {
+    VkStructureType                    sType;
+    void*                              pNext;
+    VkVideoDecodeCapabilityFlagsKHR    flags;
+} VkVideoDecodeCapabilitiesKHR;
+
+typedef struct VkVideoDecodeInfoKHR {
+    VkStructureType                   sType;
+    const void*                       pNext;
+    VkVideoDecodeFlagsKHR             flags;
+    VkBuffer                          srcBuffer;
+    VkDeviceSize                      srcBufferOffset;
+    VkDeviceSize                      srcBufferRange;
+    VkVideoPictureResourceKHR         dstPictureResource;
+    const VkVideoReferenceSlotKHR*    pSetupReferenceSlot;
+    uint32_t                          referenceSlotCount;
+    const VkVideoReferenceSlotKHR*    pReferenceSlots;
+} VkVideoDecodeInfoKHR;
+
+typedef void (VKAPI_PTR *PFN_vkCmdDecodeVideoKHR)(VkCommandBuffer commandBuffer, const VkVideoDecodeInfoKHR* pFrameInfo);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR void VKAPI_CALL vkCmdDecodeVideoKHR(
+    VkCommandBuffer                             commandBuffer,
+    const VkVideoDecodeInfoKHR*                 pFrameInfo);
+#endif
+
+
+#define VK_KHR_portability_subset 1
+#define VK_KHR_PORTABILITY_SUBSET_SPEC_VERSION 1
+#define VK_KHR_PORTABILITY_SUBSET_EXTENSION_NAME "VK_KHR_portability_subset"
+typedef struct VkPhysicalDevicePortabilitySubsetFeaturesKHR {
+    VkStructureType    sType;
+    void*              pNext;
+    VkBool32           constantAlphaColorBlendFactors;
+    VkBool32           events;
+    VkBool32           imageViewFormatReinterpretation;
+    VkBool32           imageViewFormatSwizzle;
+    VkBool32           imageView2DOn3DImage;
+    VkBool32           multisampleArrayImage;
+    VkBool32           mutableComparisonSamplers;
+    VkBool32           pointPolygons;
+    VkBool32           samplerMipLodBias;
+    VkBool32           separateStencilMaskRef;
+    VkBool32           shaderSampleRateInterpolationFunctions;
+    VkBool32           tessellationIsolines;
+    VkBool32           tessellationPointMode;
+    VkBool32           triangleFans;
+    VkBool32           vertexAttributeAccessBeyondStride;
+} VkPhysicalDevicePortabilitySubsetFeaturesKHR;
+
+typedef struct VkPhysicalDevicePortabilitySubsetPropertiesKHR {
+    VkStructureType    sType;
+    void*              pNext;
+    uint32_t           minVertexInputBindingStrideAlignment;
+} VkPhysicalDevicePortabilitySubsetPropertiesKHR;
+
+
+
+#define VK_KHR_video_encode_queue 1
+#define VK_KHR_VIDEO_ENCODE_QUEUE_SPEC_VERSION 5
+#define VK_KHR_VIDEO_ENCODE_QUEUE_EXTENSION_NAME "VK_KHR_video_encode_queue"
+
+typedef enum VkVideoEncodeFlagBitsKHR {
+    VK_VIDEO_ENCODE_DEFAULT_KHR = 0,
+    VK_VIDEO_ENCODE_RESERVED_0_BIT_KHR = 0x00000001,
+    VK_VIDEO_ENCODE_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF
+} VkVideoEncodeFlagBitsKHR;
+typedef VkFlags VkVideoEncodeFlagsKHR;
+
+typedef enum VkVideoEncodeCapabilityFlagBitsKHR {
+    VK_VIDEO_ENCODE_CAPABILITY_DEFAULT_KHR = 0,
+    VK_VIDEO_ENCODE_CAPABILITY_PRECEDING_EXTERNALLY_ENCODED_BYTES_BIT_KHR = 0x00000001,
+    VK_VIDEO_ENCODE_CAPABILITY_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF
+} VkVideoEncodeCapabilityFlagBitsKHR;
+typedef VkFlags VkVideoEncodeCapabilityFlagsKHR;
+
+typedef enum VkVideoEncodeRateControlModeFlagBitsKHR {
+    VK_VIDEO_ENCODE_RATE_CONTROL_MODE_NONE_BIT_KHR = 0,
+    VK_VIDEO_ENCODE_RATE_CONTROL_MODE_CBR_BIT_KHR = 1,
+    VK_VIDEO_ENCODE_RATE_CONTROL_MODE_VBR_BIT_KHR = 2,
+    VK_VIDEO_ENCODE_RATE_CONTROL_MODE_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF
+} VkVideoEncodeRateControlModeFlagBitsKHR;
+typedef VkFlags VkVideoEncodeRateControlModeFlagsKHR;
+
+typedef enum VkVideoEncodeRateControlFlagBitsKHR {
+    VK_VIDEO_ENCODE_RATE_CONTROL_DEFAULT_KHR = 0,
+    VK_VIDEO_ENCODE_RATE_CONTROL_RESERVED_0_BIT_KHR = 0x00000001,
+    VK_VIDEO_ENCODE_RATE_CONTROL_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF
+} VkVideoEncodeRateControlFlagBitsKHR;
+typedef VkFlags VkVideoEncodeRateControlFlagsKHR;
+typedef struct VkVideoEncodeInfoKHR {
+    VkStructureType                   sType;
+    const void*                       pNext;
+    VkVideoEncodeFlagsKHR             flags;
+    uint32_t                          qualityLevel;
+    VkBuffer                          dstBitstreamBuffer;
+    VkDeviceSize                      dstBitstreamBufferOffset;
+    VkDeviceSize                      dstBitstreamBufferMaxRange;
+    VkVideoPictureResourceKHR         srcPictureResource;
+    const VkVideoReferenceSlotKHR*    pSetupReferenceSlot;
+    uint32_t                          referenceSlotCount;
+    const VkVideoReferenceSlotKHR*    pReferenceSlots;
+    uint32_t                          precedingExternallyEncodedBytes;
+} VkVideoEncodeInfoKHR;
+
+typedef struct VkVideoEncodeCapabilitiesKHR {
+    VkStructureType                         sType;
+    void*                                   pNext;
+    VkVideoEncodeCapabilityFlagsKHR         flags;
+    VkVideoEncodeRateControlModeFlagsKHR    rateControlModes;
+    uint8_t                                 rateControlLayerCount;
+    uint8_t                                 qualityLevelCount;
+    VkExtent2D                              inputImageDataFillAlignment;
+} VkVideoEncodeCapabilitiesKHR;
+
+typedef struct VkVideoEncodeRateControlLayerInfoKHR {
+    VkStructureType    sType;
+    const void*        pNext;
+    uint32_t           averageBitrate;
+    uint32_t           maxBitrate;
+    uint32_t           frameRateNumerator;
+    uint32_t           frameRateDenominator;
+    uint32_t           virtualBufferSizeInMs;
+    uint32_t           initialVirtualBufferSizeInMs;
+} VkVideoEncodeRateControlLayerInfoKHR;
+
+typedef struct VkVideoEncodeRateControlInfoKHR {
+    VkStructureType                                sType;
+    const void*                                    pNext;
+    VkVideoEncodeRateControlFlagsKHR               flags;
+    VkVideoEncodeRateControlModeFlagBitsKHR        rateControlMode;
+    uint8_t                                        layerCount;
+    const VkVideoEncodeRateControlLayerInfoKHR*    pLayerConfigs;
+} VkVideoEncodeRateControlInfoKHR;
+
+typedef void (VKAPI_PTR *PFN_vkCmdEncodeVideoKHR)(VkCommandBuffer commandBuffer, const VkVideoEncodeInfoKHR* pEncodeInfo);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR void VKAPI_CALL vkCmdEncodeVideoKHR(
+    VkCommandBuffer                             commandBuffer,
+    const VkVideoEncodeInfoKHR*                 pEncodeInfo);
+#endif
+
+
+#define VK_EXT_video_encode_h264 1
+#include "vk_video/vulkan_video_codec_h264std.h"
+#include "vk_video/vulkan_video_codec_h264std_encode.h"
+#define VK_EXT_VIDEO_ENCODE_H264_SPEC_VERSION 7
+#define VK_EXT_VIDEO_ENCODE_H264_EXTENSION_NAME "VK_EXT_video_encode_h264"
+
+typedef enum VkVideoEncodeH264CapabilityFlagBitsEXT {
+    VK_VIDEO_ENCODE_H264_CAPABILITY_DIRECT_8X8_INFERENCE_ENABLED_BIT_EXT = 0x00000001,
+    VK_VIDEO_ENCODE_H264_CAPABILITY_DIRECT_8X8_INFERENCE_DISABLED_BIT_EXT = 0x00000002,
+    VK_VIDEO_ENCODE_H264_CAPABILITY_SEPARATE_COLOUR_PLANE_BIT_EXT = 0x00000004,
+    VK_VIDEO_ENCODE_H264_CAPABILITY_QPPRIME_Y_ZERO_TRANSFORM_BYPASS_BIT_EXT = 0x00000008,
+    VK_VIDEO_ENCODE_H264_CAPABILITY_SCALING_LISTS_BIT_EXT = 0x00000010,
+    VK_VIDEO_ENCODE_H264_CAPABILITY_HRD_COMPLIANCE_BIT_EXT = 0x00000020,
+    VK_VIDEO_ENCODE_H264_CAPABILITY_CHROMA_QP_OFFSET_BIT_EXT = 0x00000040,
+    VK_VIDEO_ENCODE_H264_CAPABILITY_SECOND_CHROMA_QP_OFFSET_BIT_EXT = 0x00000080,
+    VK_VIDEO_ENCODE_H264_CAPABILITY_PIC_INIT_QP_MINUS26_BIT_EXT = 0x00000100,
+    VK_VIDEO_ENCODE_H264_CAPABILITY_WEIGHTED_PRED_BIT_EXT = 0x00000200,
+    VK_VIDEO_ENCODE_H264_CAPABILITY_WEIGHTED_BIPRED_EXPLICIT_BIT_EXT = 0x00000400,
+    VK_VIDEO_ENCODE_H264_CAPABILITY_WEIGHTED_BIPRED_IMPLICIT_BIT_EXT = 0x00000800,
+    VK_VIDEO_ENCODE_H264_CAPABILITY_WEIGHTED_PRED_NO_TABLE_BIT_EXT = 0x00001000,
+    VK_VIDEO_ENCODE_H264_CAPABILITY_TRANSFORM_8X8_BIT_EXT = 0x00002000,
+    VK_VIDEO_ENCODE_H264_CAPABILITY_CABAC_BIT_EXT = 0x00004000,
+    VK_VIDEO_ENCODE_H264_CAPABILITY_CAVLC_BIT_EXT = 0x00008000,
+    VK_VIDEO_ENCODE_H264_CAPABILITY_DEBLOCKING_FILTER_DISABLED_BIT_EXT = 0x00010000,
+    VK_VIDEO_ENCODE_H264_CAPABILITY_DEBLOCKING_FILTER_ENABLED_BIT_EXT = 0x00020000,
+    VK_VIDEO_ENCODE_H264_CAPABILITY_DEBLOCKING_FILTER_PARTIAL_BIT_EXT = 0x00040000,
+    VK_VIDEO_ENCODE_H264_CAPABILITY_DISABLE_DIRECT_SPATIAL_MV_PRED_BIT_EXT = 0x00080000,
+    VK_VIDEO_ENCODE_H264_CAPABILITY_MULTIPLE_SLICE_PER_FRAME_BIT_EXT = 0x00100000,
+    VK_VIDEO_ENCODE_H264_CAPABILITY_SLICE_MB_COUNT_BIT_EXT = 0x00200000,
+    VK_VIDEO_ENCODE_H264_CAPABILITY_ROW_UNALIGNED_SLICE_BIT_EXT = 0x00400000,
+    VK_VIDEO_ENCODE_H264_CAPABILITY_DIFFERENT_SLICE_TYPE_BIT_EXT = 0x00800000,
+    VK_VIDEO_ENCODE_H264_CAPABILITY_B_FRAME_IN_L1_LIST_BIT_EXT = 0x01000000,
+    VK_VIDEO_ENCODE_H264_CAPABILITY_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF
+} VkVideoEncodeH264CapabilityFlagBitsEXT;
+typedef VkFlags VkVideoEncodeH264CapabilityFlagsEXT;
+
+typedef enum VkVideoEncodeH264InputModeFlagBitsEXT {
+    VK_VIDEO_ENCODE_H264_INPUT_MODE_FRAME_BIT_EXT = 0x00000001,
+    VK_VIDEO_ENCODE_H264_INPUT_MODE_SLICE_BIT_EXT = 0x00000002,
+    VK_VIDEO_ENCODE_H264_INPUT_MODE_NON_VCL_BIT_EXT = 0x00000004,
+    VK_VIDEO_ENCODE_H264_INPUT_MODE_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF
+} VkVideoEncodeH264InputModeFlagBitsEXT;
+typedef VkFlags VkVideoEncodeH264InputModeFlagsEXT;
+
+typedef enum VkVideoEncodeH264OutputModeFlagBitsEXT {
+    VK_VIDEO_ENCODE_H264_OUTPUT_MODE_FRAME_BIT_EXT = 0x00000001,
+    VK_VIDEO_ENCODE_H264_OUTPUT_MODE_SLICE_BIT_EXT = 0x00000002,
+    VK_VIDEO_ENCODE_H264_OUTPUT_MODE_NON_VCL_BIT_EXT = 0x00000004,
+    VK_VIDEO_ENCODE_H264_OUTPUT_MODE_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF
+} VkVideoEncodeH264OutputModeFlagBitsEXT;
+typedef VkFlags VkVideoEncodeH264OutputModeFlagsEXT;
+
+typedef enum VkVideoEncodeH264RateControlStructureFlagBitsEXT {
+    VK_VIDEO_ENCODE_H264_RATE_CONTROL_STRUCTURE_UNKNOWN_EXT = 0,
+    VK_VIDEO_ENCODE_H264_RATE_CONTROL_STRUCTURE_FLAT_BIT_EXT = 0x00000001,
+    VK_VIDEO_ENCODE_H264_RATE_CONTROL_STRUCTURE_DYADIC_BIT_EXT = 0x00000002,
+    VK_VIDEO_ENCODE_H264_RATE_CONTROL_STRUCTURE_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF
+} VkVideoEncodeH264RateControlStructureFlagBitsEXT;
+typedef VkFlags VkVideoEncodeH264RateControlStructureFlagsEXT;
+typedef struct VkVideoEncodeH264CapabilitiesEXT {
+    VkStructureType                        sType;
+    void*                                  pNext;
+    VkVideoEncodeH264CapabilityFlagsEXT    flags;
+    VkVideoEncodeH264InputModeFlagsEXT     inputModeFlags;
+    VkVideoEncodeH264OutputModeFlagsEXT    outputModeFlags;
+    uint8_t                                maxPPictureL0ReferenceCount;
+    uint8_t                                maxBPictureL0ReferenceCount;
+    uint8_t                                maxL1ReferenceCount;
+    VkBool32                               motionVectorsOverPicBoundariesFlag;
+    uint32_t                               maxBytesPerPicDenom;
+    uint32_t                               maxBitsPerMbDenom;
+    uint32_t                               log2MaxMvLengthHorizontal;
+    uint32_t                               log2MaxMvLengthVertical;
+} VkVideoEncodeH264CapabilitiesEXT;
+
+typedef struct VkVideoEncodeH264SessionParametersAddInfoEXT {
+    VkStructureType                            sType;
+    const void*                                pNext;
+    uint32_t                                   spsStdCount;
+    const StdVideoH264SequenceParameterSet*    pSpsStd;
+    uint32_t                                   ppsStdCount;
+    const StdVideoH264PictureParameterSet*     pPpsStd;
+} VkVideoEncodeH264SessionParametersAddInfoEXT;
+
+typedef struct VkVideoEncodeH264SessionParametersCreateInfoEXT {
+    VkStructureType                                        sType;
+    const void*                                            pNext;
+    uint32_t                                               maxSpsStdCount;
+    uint32_t                                               maxPpsStdCount;
+    const VkVideoEncodeH264SessionParametersAddInfoEXT*    pParametersAddInfo;
+} VkVideoEncodeH264SessionParametersCreateInfoEXT;
+
+typedef struct VkVideoEncodeH264DpbSlotInfoEXT {
+    VkStructureType                           sType;
+    const void*                               pNext;
+    int8_t                                    slotIndex;
+    const StdVideoEncodeH264ReferenceInfo*    pStdReferenceInfo;
+} VkVideoEncodeH264DpbSlotInfoEXT;
+
+typedef struct VkVideoEncodeH264ReferenceListsEXT {
+    VkStructureType                                      sType;
+    const void*                                          pNext;
+    uint8_t                                              referenceList0EntryCount;
+    const VkVideoEncodeH264DpbSlotInfoEXT*               pReferenceList0Entries;
+    uint8_t                                              referenceList1EntryCount;
+    const VkVideoEncodeH264DpbSlotInfoEXT*               pReferenceList1Entries;
+    const StdVideoEncodeH264RefMemMgmtCtrlOperations*    pMemMgmtCtrlOperations;
+} VkVideoEncodeH264ReferenceListsEXT;
+
+typedef struct VkVideoEncodeH264NaluSliceEXT {
+    VkStructureType                              sType;
+    const void*                                  pNext;
+    uint32_t                                     mbCount;
+    const VkVideoEncodeH264ReferenceListsEXT*    pReferenceFinalLists;
+    const StdVideoEncodeH264SliceHeader*         pSliceHeaderStd;
+} VkVideoEncodeH264NaluSliceEXT;
+
+typedef struct VkVideoEncodeH264VclFrameInfoEXT {
+    VkStructureType                              sType;
+    const void*                                  pNext;
+    const VkVideoEncodeH264ReferenceListsEXT*    pReferenceFinalLists;
+    uint32_t                                     naluSliceEntryCount;
+    const VkVideoEncodeH264NaluSliceEXT*         pNaluSliceEntries;
+    const StdVideoEncodeH264PictureInfo*         pCurrentPictureInfo;
+} VkVideoEncodeH264VclFrameInfoEXT;
+
+typedef struct VkVideoEncodeH264EmitPictureParametersEXT {
+    VkStructureType    sType;
+    const void*        pNext;
+    uint8_t            spsId;
+    VkBool32           emitSpsEnable;
+    uint32_t           ppsIdEntryCount;
+    const uint8_t*     ppsIdEntries;
+} VkVideoEncodeH264EmitPictureParametersEXT;
+
+typedef struct VkVideoEncodeH264ProfileEXT {
+    VkStructureType           sType;
+    const void*               pNext;
+    StdVideoH264ProfileIdc    stdProfileIdc;
+} VkVideoEncodeH264ProfileEXT;
+
+typedef struct VkVideoEncodeH264RateControlInfoEXT {
+    VkStructureType                                     sType;
+    const void*                                         pNext;
+    uint32_t                                            gopFrameCount;
+    uint32_t                                            idrPeriod;
+    uint32_t                                            consecutiveBFrameCount;
+    VkVideoEncodeH264RateControlStructureFlagBitsEXT    rateControlStructure;
+    uint8_t                                             temporalLayerCount;
+} VkVideoEncodeH264RateControlInfoEXT;
+
+typedef struct VkVideoEncodeH264QpEXT {
+    int32_t    qpI;
+    int32_t    qpP;
+    int32_t    qpB;
+} VkVideoEncodeH264QpEXT;
+
+typedef struct VkVideoEncodeH264FrameSizeEXT {
+    uint32_t    frameISize;
+    uint32_t    framePSize;
+    uint32_t    frameBSize;
+} VkVideoEncodeH264FrameSizeEXT;
+
+typedef struct VkVideoEncodeH264RateControlLayerInfoEXT {
+    VkStructureType                  sType;
+    const void*                      pNext;
+    uint8_t                          temporalLayerId;
+    VkBool32                         useInitialRcQp;
+    VkVideoEncodeH264QpEXT           initialRcQp;
+    VkBool32                         useMinQp;
+    VkVideoEncodeH264QpEXT           minQp;
+    VkBool32                         useMaxQp;
+    VkVideoEncodeH264QpEXT           maxQp;
+    VkBool32                         useMaxFrameSize;
+    VkVideoEncodeH264FrameSizeEXT    maxFrameSize;
+} VkVideoEncodeH264RateControlLayerInfoEXT;
+
+
+
+#define VK_EXT_video_encode_h265 1
+#include "vk_video/vulkan_video_codec_h265std.h"
+#include "vk_video/vulkan_video_codec_h265std_encode.h"
+#define VK_EXT_VIDEO_ENCODE_H265_SPEC_VERSION 7
+#define VK_EXT_VIDEO_ENCODE_H265_EXTENSION_NAME "VK_EXT_video_encode_h265"
+
+typedef enum VkVideoEncodeH265CapabilityFlagBitsEXT {
+    VK_VIDEO_ENCODE_H265_CAPABILITY_SEPARATE_COLOUR_PLANE_BIT_EXT = 0x00000001,
+    VK_VIDEO_ENCODE_H265_CAPABILITY_SCALING_LISTS_BIT_EXT = 0x00000002,
+    VK_VIDEO_ENCODE_H265_CAPABILITY_SAMPLE_ADAPTIVE_OFFSET_ENABLED_BIT_EXT = 0x00000004,
+    VK_VIDEO_ENCODE_H265_CAPABILITY_PCM_ENABLE_BIT_EXT = 0x00000008,
+    VK_VIDEO_ENCODE_H265_CAPABILITY_SPS_TEMPORAL_MVP_ENABLED_BIT_EXT = 0x00000010,
+    VK_VIDEO_ENCODE_H265_CAPABILITY_HRD_COMPLIANCE_BIT_EXT = 0x00000020,
+    VK_VIDEO_ENCODE_H265_CAPABILITY_INIT_QP_MINUS26_BIT_EXT = 0x00000040,
+    VK_VIDEO_ENCODE_H265_CAPABILITY_LOG2_PARALLEL_MERGE_LEVEL_MINUS2_BIT_EXT = 0x00000080,
+    VK_VIDEO_ENCODE_H265_CAPABILITY_SIGN_DATA_HIDING_ENABLED_BIT_EXT = 0x00000100,
+    VK_VIDEO_ENCODE_H265_CAPABILITY_TRANSFORM_SKIP_ENABLED_BIT_EXT = 0x00000200,
+    VK_VIDEO_ENCODE_H265_CAPABILITY_TRANSFORM_SKIP_DISABLED_BIT_EXT = 0x00000400,
+    VK_VIDEO_ENCODE_H265_CAPABILITY_PPS_SLICE_CHROMA_QP_OFFSETS_PRESENT_BIT_EXT = 0x00000800,
+    VK_VIDEO_ENCODE_H265_CAPABILITY_WEIGHTED_PRED_BIT_EXT = 0x00001000,
+    VK_VIDEO_ENCODE_H265_CAPABILITY_WEIGHTED_BIPRED_BIT_EXT = 0x00002000,
+    VK_VIDEO_ENCODE_H265_CAPABILITY_WEIGHTED_PRED_NO_TABLE_BIT_EXT = 0x00004000,
+    VK_VIDEO_ENCODE_H265_CAPABILITY_TRANSQUANT_BYPASS_ENABLED_BIT_EXT = 0x00008000,
+    VK_VIDEO_ENCODE_H265_CAPABILITY_ENTROPY_CODING_SYNC_ENABLED_BIT_EXT = 0x00010000,
+    VK_VIDEO_ENCODE_H265_CAPABILITY_DEBLOCKING_FILTER_OVERRIDE_ENABLED_BIT_EXT = 0x00020000,
+    VK_VIDEO_ENCODE_H265_CAPABILITY_MULTIPLE_TILE_PER_FRAME_BIT_EXT = 0x00040000,
+    VK_VIDEO_ENCODE_H265_CAPABILITY_MULTIPLE_SLICE_PER_TILE_BIT_EXT = 0x00080000,
+    VK_VIDEO_ENCODE_H265_CAPABILITY_MULTIPLE_TILE_PER_SLICE_BIT_EXT = 0x00100000,
+    VK_VIDEO_ENCODE_H265_CAPABILITY_SLICE_SEGMENT_CTB_COUNT_BIT_EXT = 0x00200000,
+    VK_VIDEO_ENCODE_H265_CAPABILITY_ROW_UNALIGNED_SLICE_SEGMENT_BIT_EXT = 0x00400000,
+    VK_VIDEO_ENCODE_H265_CAPABILITY_DEPENDENT_SLICE_SEGMENT_BIT_EXT = 0x00800000,
+    VK_VIDEO_ENCODE_H265_CAPABILITY_DIFFERENT_SLICE_TYPE_BIT_EXT = 0x01000000,
+    VK_VIDEO_ENCODE_H265_CAPABILITY_B_FRAME_IN_L1_LIST_BIT_EXT = 0x02000000,
+    VK_VIDEO_ENCODE_H265_CAPABILITY_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF
+} VkVideoEncodeH265CapabilityFlagBitsEXT;
+typedef VkFlags VkVideoEncodeH265CapabilityFlagsEXT;
+
+typedef enum VkVideoEncodeH265InputModeFlagBitsEXT {
+    VK_VIDEO_ENCODE_H265_INPUT_MODE_FRAME_BIT_EXT = 0x00000001,
+    VK_VIDEO_ENCODE_H265_INPUT_MODE_SLICE_SEGMENT_BIT_EXT = 0x00000002,
+    VK_VIDEO_ENCODE_H265_INPUT_MODE_NON_VCL_BIT_EXT = 0x00000004,
+    VK_VIDEO_ENCODE_H265_INPUT_MODE_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF
+} VkVideoEncodeH265InputModeFlagBitsEXT;
+typedef VkFlags VkVideoEncodeH265InputModeFlagsEXT;
+
+typedef enum VkVideoEncodeH265OutputModeFlagBitsEXT {
+    VK_VIDEO_ENCODE_H265_OUTPUT_MODE_FRAME_BIT_EXT = 0x00000001,
+    VK_VIDEO_ENCODE_H265_OUTPUT_MODE_SLICE_SEGMENT_BIT_EXT = 0x00000002,
+    VK_VIDEO_ENCODE_H265_OUTPUT_MODE_NON_VCL_BIT_EXT = 0x00000004,
+    VK_VIDEO_ENCODE_H265_OUTPUT_MODE_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF
+} VkVideoEncodeH265OutputModeFlagBitsEXT;
+typedef VkFlags VkVideoEncodeH265OutputModeFlagsEXT;
+
+typedef enum VkVideoEncodeH265CtbSizeFlagBitsEXT {
+    VK_VIDEO_ENCODE_H265_CTB_SIZE_16_BIT_EXT = 0x00000001,
+    VK_VIDEO_ENCODE_H265_CTB_SIZE_32_BIT_EXT = 0x00000002,
+    VK_VIDEO_ENCODE_H265_CTB_SIZE_64_BIT_EXT = 0x00000004,
+    VK_VIDEO_ENCODE_H265_CTB_SIZE_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF
+} VkVideoEncodeH265CtbSizeFlagBitsEXT;
+typedef VkFlags VkVideoEncodeH265CtbSizeFlagsEXT;
+
+typedef enum VkVideoEncodeH265TransformBlockSizeFlagBitsEXT {
+    VK_VIDEO_ENCODE_H265_TRANSFORM_BLOCK_SIZE_4_BIT_EXT = 0x00000001,
+    VK_VIDEO_ENCODE_H265_TRANSFORM_BLOCK_SIZE_8_BIT_EXT = 0x00000002,
+    VK_VIDEO_ENCODE_H265_TRANSFORM_BLOCK_SIZE_16_BIT_EXT = 0x00000004,
+    VK_VIDEO_ENCODE_H265_TRANSFORM_BLOCK_SIZE_32_BIT_EXT = 0x00000008,
+    VK_VIDEO_ENCODE_H265_TRANSFORM_BLOCK_SIZE_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF
+} VkVideoEncodeH265TransformBlockSizeFlagBitsEXT;
+typedef VkFlags VkVideoEncodeH265TransformBlockSizeFlagsEXT;
+
+typedef enum VkVideoEncodeH265RateControlStructureFlagBitsEXT {
+    VK_VIDEO_ENCODE_H265_RATE_CONTROL_STRUCTURE_UNKNOWN_EXT = 0,
+    VK_VIDEO_ENCODE_H265_RATE_CONTROL_STRUCTURE_FLAT_BIT_EXT = 0x00000001,
+    VK_VIDEO_ENCODE_H265_RATE_CONTROL_STRUCTURE_DYADIC_BIT_EXT = 0x00000002,
+    VK_VIDEO_ENCODE_H265_RATE_CONTROL_STRUCTURE_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF
+} VkVideoEncodeH265RateControlStructureFlagBitsEXT;
+typedef VkFlags VkVideoEncodeH265RateControlStructureFlagsEXT;
+typedef struct VkVideoEncodeH265CapabilitiesEXT {
+    VkStructureType                                sType;
+    void*                                          pNext;
+    VkVideoEncodeH265CapabilityFlagsEXT            flags;
+    VkVideoEncodeH265InputModeFlagsEXT             inputModeFlags;
+    VkVideoEncodeH265OutputModeFlagsEXT            outputModeFlags;
+    VkVideoEncodeH265CtbSizeFlagsEXT               ctbSizes;
+    VkVideoEncodeH265TransformBlockSizeFlagsEXT    transformBlockSizes;
+    uint8_t                                        maxPPictureL0ReferenceCount;
+    uint8_t                                        maxBPictureL0ReferenceCount;
+    uint8_t                                        maxL1ReferenceCount;
+    uint8_t                                        maxSubLayersCount;
+    uint8_t                                        minLog2MinLumaCodingBlockSizeMinus3;
+    uint8_t                                        maxLog2MinLumaCodingBlockSizeMinus3;
+    uint8_t                                        minLog2MinLumaTransformBlockSizeMinus2;
+    uint8_t                                        maxLog2MinLumaTransformBlockSizeMinus2;
+    uint8_t                                        minMaxTransformHierarchyDepthInter;
+    uint8_t                                        maxMaxTransformHierarchyDepthInter;
+    uint8_t                                        minMaxTransformHierarchyDepthIntra;
+    uint8_t                                        maxMaxTransformHierarchyDepthIntra;
+    uint8_t                                        maxDiffCuQpDeltaDepth;
+    uint8_t                                        minMaxNumMergeCand;
+    uint8_t                                        maxMaxNumMergeCand;
+} VkVideoEncodeH265CapabilitiesEXT;
+
+typedef struct VkVideoEncodeH265SessionParametersAddInfoEXT {
+    VkStructureType                            sType;
+    const void*                                pNext;
+    uint32_t                                   vpsStdCount;
+    const StdVideoH265VideoParameterSet*       pVpsStd;
+    uint32_t                                   spsStdCount;
+    const StdVideoH265SequenceParameterSet*    pSpsStd;
+    uint32_t                                   ppsStdCount;
+    const StdVideoH265PictureParameterSet*     pPpsStd;
+} VkVideoEncodeH265SessionParametersAddInfoEXT;
+
+typedef struct VkVideoEncodeH265SessionParametersCreateInfoEXT {
+    VkStructureType                                        sType;
+    const void*                                            pNext;
+    uint32_t                                               maxVpsStdCount;
+    uint32_t                                               maxSpsStdCount;
+    uint32_t                                               maxPpsStdCount;
+    const VkVideoEncodeH265SessionParametersAddInfoEXT*    pParametersAddInfo;
+} VkVideoEncodeH265SessionParametersCreateInfoEXT;
+
+typedef struct VkVideoEncodeH265DpbSlotInfoEXT {
+    VkStructureType                           sType;
+    const void*                               pNext;
+    int8_t                                    slotIndex;
+    const StdVideoEncodeH265ReferenceInfo*    pStdReferenceInfo;
+} VkVideoEncodeH265DpbSlotInfoEXT;
+
+typedef struct VkVideoEncodeH265ReferenceListsEXT {
+    VkStructureType                                    sType;
+    const void*                                        pNext;
+    uint8_t                                            referenceList0EntryCount;
+    const VkVideoEncodeH265DpbSlotInfoEXT*             pReferenceList0Entries;
+    uint8_t                                            referenceList1EntryCount;
+    const VkVideoEncodeH265DpbSlotInfoEXT*             pReferenceList1Entries;
+    const StdVideoEncodeH265ReferenceModifications*    pReferenceModifications;
+} VkVideoEncodeH265ReferenceListsEXT;
+
+typedef struct VkVideoEncodeH265NaluSliceSegmentEXT {
+    VkStructureType                                sType;
+    const void*                                    pNext;
+    uint32_t                                       ctbCount;
+    const VkVideoEncodeH265ReferenceListsEXT*      pReferenceFinalLists;
+    const StdVideoEncodeH265SliceSegmentHeader*    pSliceSegmentHeaderStd;
+} VkVideoEncodeH265NaluSliceSegmentEXT;
+
+typedef struct VkVideoEncodeH265VclFrameInfoEXT {
+    VkStructureType                                sType;
+    const void*                                    pNext;
+    const VkVideoEncodeH265ReferenceListsEXT*      pReferenceFinalLists;
+    uint32_t                                       naluSliceSegmentEntryCount;
+    const VkVideoEncodeH265NaluSliceSegmentEXT*    pNaluSliceSegmentEntries;
+    const StdVideoEncodeH265PictureInfo*           pCurrentPictureInfo;
+} VkVideoEncodeH265VclFrameInfoEXT;
+
+typedef struct VkVideoEncodeH265EmitPictureParametersEXT {
+    VkStructureType    sType;
+    const void*        pNext;
+    uint8_t            vpsId;
+    uint8_t            spsId;
+    VkBool32           emitVpsEnable;
+    VkBool32           emitSpsEnable;
+    uint32_t           ppsIdEntryCount;
+    const uint8_t*     ppsIdEntries;
+} VkVideoEncodeH265EmitPictureParametersEXT;
+
+typedef struct VkVideoEncodeH265ProfileEXT {
+    VkStructureType           sType;
+    const void*               pNext;
+    StdVideoH265ProfileIdc    stdProfileIdc;
+} VkVideoEncodeH265ProfileEXT;
+
+typedef struct VkVideoEncodeH265RateControlInfoEXT {
+    VkStructureType                                     sType;
+    const void*                                         pNext;
+    uint32_t                                            gopFrameCount;
+    uint32_t                                            idrPeriod;
+    uint32_t                                            consecutiveBFrameCount;
+    VkVideoEncodeH265RateControlStructureFlagBitsEXT    rateControlStructure;
+    uint8_t                                             subLayerCount;
+} VkVideoEncodeH265RateControlInfoEXT;
+
+typedef struct VkVideoEncodeH265QpEXT {
+    int32_t    qpI;
+    int32_t    qpP;
+    int32_t    qpB;
+} VkVideoEncodeH265QpEXT;
+
+typedef struct VkVideoEncodeH265FrameSizeEXT {
+    uint32_t    frameISize;
+    uint32_t    framePSize;
+    uint32_t    frameBSize;
+} VkVideoEncodeH265FrameSizeEXT;
+
+typedef struct VkVideoEncodeH265RateControlLayerInfoEXT {
+    VkStructureType                  sType;
+    const void*                      pNext;
+    uint8_t                          temporalId;
+    VkBool32                         useInitialRcQp;
+    VkVideoEncodeH265QpEXT           initialRcQp;
+    VkBool32                         useMinQp;
+    VkVideoEncodeH265QpEXT           minQp;
+    VkBool32                         useMaxQp;
+    VkVideoEncodeH265QpEXT           maxQp;
+    VkBool32                         useMaxFrameSize;
+    VkVideoEncodeH265FrameSizeEXT    maxFrameSize;
+} VkVideoEncodeH265RateControlLayerInfoEXT;
+
+
+
+#define VK_EXT_video_decode_h264 1
+#include "vk_video/vulkan_video_codec_h264std_decode.h"
+#define VK_EXT_VIDEO_DECODE_H264_SPEC_VERSION 5
+#define VK_EXT_VIDEO_DECODE_H264_EXTENSION_NAME "VK_EXT_video_decode_h264"
+
+typedef enum VkVideoDecodeH264PictureLayoutFlagBitsEXT {
+    VK_VIDEO_DECODE_H264_PICTURE_LAYOUT_PROGRESSIVE_EXT = 0,
+    VK_VIDEO_DECODE_H264_PICTURE_LAYOUT_INTERLACED_INTERLEAVED_LINES_BIT_EXT = 0x00000001,
+    VK_VIDEO_DECODE_H264_PICTURE_LAYOUT_INTERLACED_SEPARATE_PLANES_BIT_EXT = 0x00000002,
+    VK_VIDEO_DECODE_H264_PICTURE_LAYOUT_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF
+} VkVideoDecodeH264PictureLayoutFlagBitsEXT;
+typedef VkFlags VkVideoDecodeH264PictureLayoutFlagsEXT;
+typedef struct VkVideoDecodeH264ProfileEXT {
+    VkStructureType                           sType;
+    const void*                               pNext;
+    StdVideoH264ProfileIdc                    stdProfileIdc;
+    VkVideoDecodeH264PictureLayoutFlagsEXT    pictureLayout;
+} VkVideoDecodeH264ProfileEXT;
+
+typedef struct VkVideoDecodeH264CapabilitiesEXT {
+    VkStructureType      sType;
+    void*                pNext;
+    StdVideoH264Level    maxLevel;
+    VkOffset2D           fieldOffsetGranularity;
+} VkVideoDecodeH264CapabilitiesEXT;
+
+typedef struct VkVideoDecodeH264SessionParametersAddInfoEXT {
+    VkStructureType                            sType;
+    const void*                                pNext;
+    uint32_t                                   spsStdCount;
+    const StdVideoH264SequenceParameterSet*    pSpsStd;
+    uint32_t                                   ppsStdCount;
+    const StdVideoH264PictureParameterSet*     pPpsStd;
+} VkVideoDecodeH264SessionParametersAddInfoEXT;
+
+typedef struct VkVideoDecodeH264SessionParametersCreateInfoEXT {
+    VkStructureType                                        sType;
+    const void*                                            pNext;
+    uint32_t                                               maxSpsStdCount;
+    uint32_t                                               maxPpsStdCount;
+    const VkVideoDecodeH264SessionParametersAddInfoEXT*    pParametersAddInfo;
+} VkVideoDecodeH264SessionParametersCreateInfoEXT;
+
+typedef struct VkVideoDecodeH264PictureInfoEXT {
+    VkStructureType                         sType;
+    const void*                             pNext;
+    const StdVideoDecodeH264PictureInfo*    pStdPictureInfo;
+    uint32_t                                slicesCount;
+    const uint32_t*                         pSlicesDataOffsets;
+} VkVideoDecodeH264PictureInfoEXT;
+
+typedef struct VkVideoDecodeH264MvcEXT {
+    VkStructureType                 sType;
+    const void*                     pNext;
+    const StdVideoDecodeH264Mvc*    pStdMvc;
+} VkVideoDecodeH264MvcEXT;
+
+typedef struct VkVideoDecodeH264DpbSlotInfoEXT {
+    VkStructureType                           sType;
+    const void*                               pNext;
+    const StdVideoDecodeH264ReferenceInfo*    pStdReferenceInfo;
+} VkVideoDecodeH264DpbSlotInfoEXT;
+
+
+
+#define VK_EXT_video_decode_h265 1
+#include "vk_video/vulkan_video_codec_h265std_decode.h"
+#define VK_EXT_VIDEO_DECODE_H265_SPEC_VERSION 3
+#define VK_EXT_VIDEO_DECODE_H265_EXTENSION_NAME "VK_EXT_video_decode_h265"
+typedef struct VkVideoDecodeH265ProfileEXT {
+    VkStructureType           sType;
+    const void*               pNext;
+    StdVideoH265ProfileIdc    stdProfileIdc;
+} VkVideoDecodeH265ProfileEXT;
+
+typedef struct VkVideoDecodeH265CapabilitiesEXT {
+    VkStructureType      sType;
+    void*                pNext;
+    StdVideoH265Level    maxLevel;
+} VkVideoDecodeH265CapabilitiesEXT;
+
+typedef struct VkVideoDecodeH265SessionParametersAddInfoEXT {
+    VkStructureType                            sType;
+    const void*                                pNext;
+    uint32_t                                   vpsStdCount;
+    const StdVideoH265VideoParameterSet*       pVpsStd;
+    uint32_t                                   spsStdCount;
+    const StdVideoH265SequenceParameterSet*    pSpsStd;
+    uint32_t                                   ppsStdCount;
+    const StdVideoH265PictureParameterSet*     pPpsStd;
+} VkVideoDecodeH265SessionParametersAddInfoEXT;
+
+typedef struct VkVideoDecodeH265SessionParametersCreateInfoEXT {
+    VkStructureType                                        sType;
+    const void*                                            pNext;
+    uint32_t                                               maxVpsStdCount;
+    uint32_t                                               maxSpsStdCount;
+    uint32_t                                               maxPpsStdCount;
+    const VkVideoDecodeH265SessionParametersAddInfoEXT*    pParametersAddInfo;
+} VkVideoDecodeH265SessionParametersCreateInfoEXT;
+
+typedef struct VkVideoDecodeH265PictureInfoEXT {
+    VkStructureType                   sType;
+    const void*                       pNext;
+    StdVideoDecodeH265PictureInfo*    pStdPictureInfo;
+    uint32_t                          slicesCount;
+    const uint32_t*                   pSlicesDataOffsets;
+} VkVideoDecodeH265PictureInfoEXT;
+
+typedef struct VkVideoDecodeH265DpbSlotInfoEXT {
+    VkStructureType                           sType;
+    const void*                               pNext;
+    const StdVideoDecodeH265ReferenceInfo*    pStdReferenceInfo;
+} VkVideoDecodeH265DpbSlotInfoEXT;
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
--- a/src/include/vulkan/vulkan_core.h
+++ b/src/include/vulkan/vulkan_core.h
--- a/src/include/vulkan/vulkan_directfb.h
+++ b/src/include/vulkan/vulkan_directfb.h
@@ -0,0 +1,54 @@
+#ifndef VULKAN_DIRECTFB_H_
+#define VULKAN_DIRECTFB_H_ 1
+
+/*
+** Copyright 2015-2022 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_directfb_surface 1
+#define VK_EXT_DIRECTFB_SURFACE_SPEC_VERSION 1
+#define VK_EXT_DIRECTFB_SURFACE_EXTENSION_NAME "VK_EXT_directfb_surface"
+typedef VkFlags VkDirectFBSurfaceCreateFlagsEXT;
+typedef struct VkDirectFBSurfaceCreateInfoEXT {
+    VkStructureType                    sType;
+    const void*                        pNext;
+    VkDirectFBSurfaceCreateFlagsEXT    flags;
+    IDirectFB*                         dfb;
+    IDirectFBSurface*                  surface;
+} VkDirectFBSurfaceCreateInfoEXT;
+
+typedef VkResult (VKAPI_PTR *PFN_vkCreateDirectFBSurfaceEXT)(VkInstance instance, const VkDirectFBSurfaceCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface);
+typedef VkBool32 (VKAPI_PTR *PFN_vkGetPhysicalDeviceDirectFBPresentationSupportEXT)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, IDirectFB* dfb);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR VkResult VKAPI_CALL vkCreateDirectFBSurfaceEXT(
+    VkInstance                                  instance,
+    const VkDirectFBSurfaceCreateInfoEXT*       pCreateInfo,
+    const VkAllocationCallbacks*                pAllocator,
+    VkSurfaceKHR*                               pSurface);
+
+VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceDirectFBPresentationSupportEXT(
+    VkPhysicalDevice                            physicalDevice,
+    uint32_t                                    queueFamilyIndex,
+    IDirectFB*                                  dfb);
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
--- a/src/include/vulkan/vulkan_enums.hpp
+++ b/src/include/vulkan/vulkan_enums.hpp
--- a/src/include/vulkan/vulkan_format_traits.hpp
+++ b/src/include/vulkan/vulkan_format_traits.hpp
--- a/src/include/vulkan/vulkan_fuchsia.h
+++ b/src/include/vulkan/vulkan_fuchsia.h
@@ -0,0 +1,258 @@
+#ifndef VULKAN_FUCHSIA_H_
+#define VULKAN_FUCHSIA_H_ 1
+
+/*
+** Copyright 2015-2022 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_FUCHSIA_imagepipe_surface 1
+#define VK_FUCHSIA_IMAGEPIPE_SURFACE_SPEC_VERSION 1
+#define VK_FUCHSIA_IMAGEPIPE_SURFACE_EXTENSION_NAME "VK_FUCHSIA_imagepipe_surface"
+typedef VkFlags VkImagePipeSurfaceCreateFlagsFUCHSIA;
+typedef struct VkImagePipeSurfaceCreateInfoFUCHSIA {
+    VkStructureType                         sType;
+    const void*                             pNext;
+    VkImagePipeSurfaceCreateFlagsFUCHSIA    flags;
+    zx_handle_t                             imagePipeHandle;
+} VkImagePipeSurfaceCreateInfoFUCHSIA;
+
+typedef VkResult (VKAPI_PTR *PFN_vkCreateImagePipeSurfaceFUCHSIA)(VkInstance instance, const VkImagePipeSurfaceCreateInfoFUCHSIA* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR VkResult VKAPI_CALL vkCreateImagePipeSurfaceFUCHSIA(
+    VkInstance                                  instance,
+    const VkImagePipeSurfaceCreateInfoFUCHSIA*  pCreateInfo,
+    const VkAllocationCallbacks*                pAllocator,
+    VkSurfaceKHR*                               pSurface);
+#endif
+
+
+#define VK_FUCHSIA_external_memory 1
+#define VK_FUCHSIA_EXTERNAL_MEMORY_SPEC_VERSION 1
+#define VK_FUCHSIA_EXTERNAL_MEMORY_EXTENSION_NAME "VK_FUCHSIA_external_memory"
+typedef struct VkImportMemoryZirconHandleInfoFUCHSIA {
+    VkStructureType                       sType;
+    const void*                           pNext;
+    VkExternalMemoryHandleTypeFlagBits    handleType;
+    zx_handle_t                           handle;
+} VkImportMemoryZirconHandleInfoFUCHSIA;
+
+typedef struct VkMemoryZirconHandlePropertiesFUCHSIA {
+    VkStructureType    sType;
+    void*              pNext;
+    uint32_t           memoryTypeBits;
+} VkMemoryZirconHandlePropertiesFUCHSIA;
+
+typedef struct VkMemoryGetZirconHandleInfoFUCHSIA {
+    VkStructureType                       sType;
+    const void*                           pNext;
+    VkDeviceMemory                        memory;
+    VkExternalMemoryHandleTypeFlagBits    handleType;
+} VkMemoryGetZirconHandleInfoFUCHSIA;
+
+typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryZirconHandleFUCHSIA)(VkDevice device, const VkMemoryGetZirconHandleInfoFUCHSIA* pGetZirconHandleInfo, zx_handle_t* pZirconHandle);
+typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryZirconHandlePropertiesFUCHSIA)(VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, zx_handle_t zirconHandle, VkMemoryZirconHandlePropertiesFUCHSIA* pMemoryZirconHandleProperties);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryZirconHandleFUCHSIA(
+    VkDevice                                    device,
+    const VkMemoryGetZirconHandleInfoFUCHSIA*   pGetZirconHandleInfo,
+    zx_handle_t*                                pZirconHandle);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryZirconHandlePropertiesFUCHSIA(
+    VkDevice                                    device,
+    VkExternalMemoryHandleTypeFlagBits          handleType,
+    zx_handle_t                                 zirconHandle,
+    VkMemoryZirconHandlePropertiesFUCHSIA*      pMemoryZirconHandleProperties);
+#endif
+
+
+#define VK_FUCHSIA_external_semaphore 1
+#define VK_FUCHSIA_EXTERNAL_SEMAPHORE_SPEC_VERSION 1
+#define VK_FUCHSIA_EXTERNAL_SEMAPHORE_EXTENSION_NAME "VK_FUCHSIA_external_semaphore"
+typedef struct VkImportSemaphoreZirconHandleInfoFUCHSIA {
+    VkStructureType                          sType;
+    const void*                              pNext;
+    VkSemaphore                              semaphore;
+    VkSemaphoreImportFlags                   flags;
+    VkExternalSemaphoreHandleTypeFlagBits    handleType;
+    zx_handle_t                              zirconHandle;
+} VkImportSemaphoreZirconHandleInfoFUCHSIA;
+
+typedef struct VkSemaphoreGetZirconHandleInfoFUCHSIA {
+    VkStructureType                          sType;
+    const void*                              pNext;
+    VkSemaphore                              semaphore;
+    VkExternalSemaphoreHandleTypeFlagBits    handleType;
+} VkSemaphoreGetZirconHandleInfoFUCHSIA;
+
+typedef VkResult (VKAPI_PTR *PFN_vkImportSemaphoreZirconHandleFUCHSIA)(VkDevice device, const VkImportSemaphoreZirconHandleInfoFUCHSIA* pImportSemaphoreZirconHandleInfo);
+typedef VkResult (VKAPI_PTR *PFN_vkGetSemaphoreZirconHandleFUCHSIA)(VkDevice device, const VkSemaphoreGetZirconHandleInfoFUCHSIA* pGetZirconHandleInfo, zx_handle_t* pZirconHandle);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR VkResult VKAPI_CALL vkImportSemaphoreZirconHandleFUCHSIA(
+    VkDevice                                    device,
+    const VkImportSemaphoreZirconHandleInfoFUCHSIA* pImportSemaphoreZirconHandleInfo);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkGetSemaphoreZirconHandleFUCHSIA(
+    VkDevice                                    device,
+    const VkSemaphoreGetZirconHandleInfoFUCHSIA* pGetZirconHandleInfo,
+    zx_handle_t*                                pZirconHandle);
+#endif
+
+
+#define VK_FUCHSIA_buffer_collection 1
+VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkBufferCollectionFUCHSIA)
+#define VK_FUCHSIA_BUFFER_COLLECTION_SPEC_VERSION 2
+#define VK_FUCHSIA_BUFFER_COLLECTION_EXTENSION_NAME "VK_FUCHSIA_buffer_collection"
+typedef VkFlags VkImageFormatConstraintsFlagsFUCHSIA;
+
+typedef enum VkImageConstraintsInfoFlagBitsFUCHSIA {
+    VK_IMAGE_CONSTRAINTS_INFO_CPU_READ_RARELY_FUCHSIA = 0x00000001,
+    VK_IMAGE_CONSTRAINTS_INFO_CPU_READ_OFTEN_FUCHSIA = 0x00000002,
+    VK_IMAGE_CONSTRAINTS_INFO_CPU_WRITE_RARELY_FUCHSIA = 0x00000004,
+    VK_IMAGE_CONSTRAINTS_INFO_CPU_WRITE_OFTEN_FUCHSIA = 0x00000008,
+    VK_IMAGE_CONSTRAINTS_INFO_PROTECTED_OPTIONAL_FUCHSIA = 0x00000010,
+    VK_IMAGE_CONSTRAINTS_INFO_FLAG_BITS_MAX_ENUM_FUCHSIA = 0x7FFFFFFF
+} VkImageConstraintsInfoFlagBitsFUCHSIA;
+typedef VkFlags VkImageConstraintsInfoFlagsFUCHSIA;
+typedef struct VkBufferCollectionCreateInfoFUCHSIA {
+    VkStructureType    sType;
+    const void*        pNext;
+    zx_handle_t        collectionToken;
+} VkBufferCollectionCreateInfoFUCHSIA;
+
+typedef struct VkImportMemoryBufferCollectionFUCHSIA {
+    VkStructureType              sType;
+    const void*                  pNext;
+    VkBufferCollectionFUCHSIA    collection;
+    uint32_t                     index;
+} VkImportMemoryBufferCollectionFUCHSIA;
+
+typedef struct VkBufferCollectionImageCreateInfoFUCHSIA {
+    VkStructureType              sType;
+    const void*                  pNext;
+    VkBufferCollectionFUCHSIA    collection;
+    uint32_t                     index;
+} VkBufferCollectionImageCreateInfoFUCHSIA;
+
+typedef struct VkBufferCollectionConstraintsInfoFUCHSIA {
+    VkStructureType    sType;
+    const void*        pNext;
+    uint32_t           minBufferCount;
+    uint32_t           maxBufferCount;
+    uint32_t           minBufferCountForCamping;
+    uint32_t           minBufferCountForDedicatedSlack;
+    uint32_t           minBufferCountForSharedSlack;
+} VkBufferCollectionConstraintsInfoFUCHSIA;
+
+typedef struct VkBufferConstraintsInfoFUCHSIA {
+    VkStructureType                             sType;
+    const void*                                 pNext;
+    VkBufferCreateInfo                          createInfo;
+    VkFormatFeatureFlags                        requiredFormatFeatures;
+    VkBufferCollectionConstraintsInfoFUCHSIA    bufferCollectionConstraints;
+} VkBufferConstraintsInfoFUCHSIA;
+
+typedef struct VkBufferCollectionBufferCreateInfoFUCHSIA {
+    VkStructureType              sType;
+    const void*                  pNext;
+    VkBufferCollectionFUCHSIA    collection;
+    uint32_t                     index;
+} VkBufferCollectionBufferCreateInfoFUCHSIA;
+
+typedef struct VkSysmemColorSpaceFUCHSIA {
+    VkStructureType    sType;
+    const void*        pNext;
+    uint32_t           colorSpace;
+} VkSysmemColorSpaceFUCHSIA;
+
+typedef struct VkBufferCollectionPropertiesFUCHSIA {
+    VkStructureType                  sType;
+    void*                            pNext;
+    uint32_t                         memoryTypeBits;
+    uint32_t                         bufferCount;
+    uint32_t                         createInfoIndex;
+    uint64_t                         sysmemPixelFormat;
+    VkFormatFeatureFlags             formatFeatures;
+    VkSysmemColorSpaceFUCHSIA        sysmemColorSpaceIndex;
+    VkComponentMapping               samplerYcbcrConversionComponents;
+    VkSamplerYcbcrModelConversion    suggestedYcbcrModel;
+    VkSamplerYcbcrRange              suggestedYcbcrRange;
+    VkChromaLocation                 suggestedXChromaOffset;
+    VkChromaLocation                 suggestedYChromaOffset;
+} VkBufferCollectionPropertiesFUCHSIA;
+
+typedef struct VkImageFormatConstraintsInfoFUCHSIA {
+    VkStructureType                         sType;
+    const void*                             pNext;
+    VkImageCreateInfo                       imageCreateInfo;
+    VkFormatFeatureFlags                    requiredFormatFeatures;
+    VkImageFormatConstraintsFlagsFUCHSIA    flags;
+    uint64_t                                sysmemPixelFormat;
+    uint32_t                                colorSpaceCount;
+    const VkSysmemColorSpaceFUCHSIA*        pColorSpaces;
+} VkImageFormatConstraintsInfoFUCHSIA;
+
+typedef struct VkImageConstraintsInfoFUCHSIA {
+    VkStructureType                               sType;
+    const void*                                   pNext;
+    uint32_t                                      formatConstraintsCount;
+    const VkImageFormatConstraintsInfoFUCHSIA*    pFormatConstraints;
+    VkBufferCollectionConstraintsInfoFUCHSIA      bufferCollectionConstraints;
+    VkImageConstraintsInfoFlagsFUCHSIA            flags;
+} VkImageConstraintsInfoFUCHSIA;
+
+typedef VkResult (VKAPI_PTR *PFN_vkCreateBufferCollectionFUCHSIA)(VkDevice device, const VkBufferCollectionCreateInfoFUCHSIA* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBufferCollectionFUCHSIA* pCollection);
+typedef VkResult (VKAPI_PTR *PFN_vkSetBufferCollectionImageConstraintsFUCHSIA)(VkDevice device, VkBufferCollectionFUCHSIA collection, const VkImageConstraintsInfoFUCHSIA* pImageConstraintsInfo);
+typedef VkResult (VKAPI_PTR *PFN_vkSetBufferCollectionBufferConstraintsFUCHSIA)(VkDevice device, VkBufferCollectionFUCHSIA collection, const VkBufferConstraintsInfoFUCHSIA* pBufferConstraintsInfo);
+typedef void (VKAPI_PTR *PFN_vkDestroyBufferCollectionFUCHSIA)(VkDevice device, VkBufferCollectionFUCHSIA collection, const VkAllocationCallbacks* pAllocator);
+typedef VkResult (VKAPI_PTR *PFN_vkGetBufferCollectionPropertiesFUCHSIA)(VkDevice device, VkBufferCollectionFUCHSIA collection, VkBufferCollectionPropertiesFUCHSIA* pProperties);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR VkResult VKAPI_CALL vkCreateBufferCollectionFUCHSIA(
+    VkDevice                                    device,
+    const VkBufferCollectionCreateInfoFUCHSIA*  pCreateInfo,
+    const VkAllocationCallbacks*                pAllocator,
+    VkBufferCollectionFUCHSIA*                  pCollection);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkSetBufferCollectionImageConstraintsFUCHSIA(
+    VkDevice                                    device,
+    VkBufferCollectionFUCHSIA                   collection,
+    const VkImageConstraintsInfoFUCHSIA*        pImageConstraintsInfo);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkSetBufferCollectionBufferConstraintsFUCHSIA(
+    VkDevice                                    device,
+    VkBufferCollectionFUCHSIA                   collection,
+    const VkBufferConstraintsInfoFUCHSIA*       pBufferConstraintsInfo);
+
+VKAPI_ATTR void VKAPI_CALL vkDestroyBufferCollectionFUCHSIA(
+    VkDevice                                    device,
+    VkBufferCollectionFUCHSIA                   collection,
+    const VkAllocationCallbacks*                pAllocator);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkGetBufferCollectionPropertiesFUCHSIA(
+    VkDevice                                    device,
+    VkBufferCollectionFUCHSIA                   collection,
+    VkBufferCollectionPropertiesFUCHSIA*        pProperties);
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
--- a/src/include/vulkan/vulkan_funcs.hpp
+++ b/src/include/vulkan/vulkan_funcs.hpp
--- a/src/include/vulkan/vulkan_ggp.h
+++ b/src/include/vulkan/vulkan_ggp.h
@@ -0,0 +1,58 @@
+#ifndef VULKAN_GGP_H_
+#define VULKAN_GGP_H_ 1
+
+/*
+** Copyright 2015-2022 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_GGP_stream_descriptor_surface 1
+#define VK_GGP_STREAM_DESCRIPTOR_SURFACE_SPEC_VERSION 1
+#define VK_GGP_STREAM_DESCRIPTOR_SURFACE_EXTENSION_NAME "VK_GGP_stream_descriptor_surface"
+typedef VkFlags VkStreamDescriptorSurfaceCreateFlagsGGP;
+typedef struct VkStreamDescriptorSurfaceCreateInfoGGP {
+    VkStructureType                            sType;
+    const void*                                pNext;
+    VkStreamDescriptorSurfaceCreateFlagsGGP    flags;
+    GgpStreamDescriptor                        streamDescriptor;
+} VkStreamDescriptorSurfaceCreateInfoGGP;
+
+typedef VkResult (VKAPI_PTR *PFN_vkCreateStreamDescriptorSurfaceGGP)(VkInstance instance, const VkStreamDescriptorSurfaceCreateInfoGGP* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR VkResult VKAPI_CALL vkCreateStreamDescriptorSurfaceGGP(
+    VkInstance                                  instance,
+    const VkStreamDescriptorSurfaceCreateInfoGGP* pCreateInfo,
+    const VkAllocationCallbacks*                pAllocator,
+    VkSurfaceKHR*                               pSurface);
+#endif
+
+
+#define VK_GGP_frame_token 1
+#define VK_GGP_FRAME_TOKEN_SPEC_VERSION   1
+#define VK_GGP_FRAME_TOKEN_EXTENSION_NAME "VK_GGP_frame_token"
+typedef struct VkPresentFrameTokenGGP {
+    VkStructureType    sType;
+    const void*        pNext;
+    GgpFrameToken      frameToken;
+} VkPresentFrameTokenGGP;
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
--- a/src/include/vulkan/vulkan_handles.hpp
+++ b/src/include/vulkan/vulkan_handles.hpp
--- a/src/include/vulkan/vulkan_hash.hpp
+++ b/src/include/vulkan/vulkan_hash.hpp
--- a/src/include/vulkan/vulkan_ios.h
+++ b/src/include/vulkan/vulkan_ios.h
@@ -0,0 +1,47 @@
+#ifndef VULKAN_IOS_H_
+#define VULKAN_IOS_H_ 1
+
+/*
+** Copyright 2015-2022 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
--- a/src/include/vulkan/vulkan_macos.h
+++ b/src/include/vulkan/vulkan_macos.h
@@ -0,0 +1,47 @@
+#ifndef VULKAN_MACOS_H_
+#define VULKAN_MACOS_H_ 1
+
+/*
+** Copyright 2015-2022 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
--- a/src/include/vulkan/vulkan_metal.h
+++ b/src/include/vulkan/vulkan_metal.h
@@ -0,0 +1,193 @@
+#ifndef VULKAN_METAL_H_
+#define VULKAN_METAL_H_ 1
+
+/*
+** Copyright 2015-2022 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
+
+
+#define VK_EXT_metal_objects 1
+#ifdef __OBJC__
+@protocol MTLDevice;
+typedef id<MTLDevice> MTLDevice_id;
+#else
+typedef void* MTLDevice_id;
+#endif
+
+#ifdef __OBJC__
+@protocol MTLCommandQueue;
+typedef id<MTLCommandQueue> MTLCommandQueue_id;
+#else
+typedef void* MTLCommandQueue_id;
+#endif
+
+#ifdef __OBJC__
+@protocol MTLBuffer;
+typedef id<MTLBuffer> MTLBuffer_id;
+#else
+typedef void* MTLBuffer_id;
+#endif
+
+#ifdef __OBJC__
+@protocol MTLTexture;
+typedef id<MTLTexture> MTLTexture_id;
+#else
+typedef void* MTLTexture_id;
+#endif
+
+typedef struct __IOSurface* IOSurfaceRef;
+#ifdef __OBJC__
+@protocol MTLSharedEvent;
+typedef id<MTLSharedEvent> MTLSharedEvent_id;
+#else
+typedef void* MTLSharedEvent_id;
+#endif
+
+#define VK_EXT_METAL_OBJECTS_SPEC_VERSION 1
+#define VK_EXT_METAL_OBJECTS_EXTENSION_NAME "VK_EXT_metal_objects"
+
+typedef enum VkExportMetalObjectTypeFlagBitsEXT {
+    VK_EXPORT_METAL_OBJECT_TYPE_METAL_DEVICE_BIT_EXT = 0x00000001,
+    VK_EXPORT_METAL_OBJECT_TYPE_METAL_COMMAND_QUEUE_BIT_EXT = 0x00000002,
+    VK_EXPORT_METAL_OBJECT_TYPE_METAL_BUFFER_BIT_EXT = 0x00000004,
+    VK_EXPORT_METAL_OBJECT_TYPE_METAL_TEXTURE_BIT_EXT = 0x00000008,
+    VK_EXPORT_METAL_OBJECT_TYPE_METAL_IOSURFACE_BIT_EXT = 0x00000010,
+    VK_EXPORT_METAL_OBJECT_TYPE_METAL_SHARED_EVENT_BIT_EXT = 0x00000020,
+    VK_EXPORT_METAL_OBJECT_TYPE_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF
+} VkExportMetalObjectTypeFlagBitsEXT;
+typedef VkFlags VkExportMetalObjectTypeFlagsEXT;
+typedef struct VkExportMetalObjectCreateInfoEXT {
+    VkStructureType                       sType;
+    const void*                           pNext;
+    VkExportMetalObjectTypeFlagBitsEXT    exportObjectType;
+} VkExportMetalObjectCreateInfoEXT;
+
+typedef struct VkExportMetalObjectsInfoEXT {
+    VkStructureType    sType;
+    const void*        pNext;
+} VkExportMetalObjectsInfoEXT;
+
+typedef struct VkExportMetalDeviceInfoEXT {
+    VkStructureType    sType;
+    const void*        pNext;
+    MTLDevice_id       mtlDevice;
+} VkExportMetalDeviceInfoEXT;
+
+typedef struct VkExportMetalCommandQueueInfoEXT {
+    VkStructureType       sType;
+    const void*           pNext;
+    VkQueue               queue;
+    MTLCommandQueue_id    mtlCommandQueue;
+} VkExportMetalCommandQueueInfoEXT;
+
+typedef struct VkExportMetalBufferInfoEXT {
+    VkStructureType    sType;
+    const void*        pNext;
+    VkDeviceMemory     memory;
+    MTLBuffer_id       mtlBuffer;
+} VkExportMetalBufferInfoEXT;
+
+typedef struct VkImportMetalBufferInfoEXT {
+    VkStructureType    sType;
+    const void*        pNext;
+    MTLBuffer_id       mtlBuffer;
+} VkImportMetalBufferInfoEXT;
+
+typedef struct VkExportMetalTextureInfoEXT {
+    VkStructureType          sType;
+    const void*              pNext;
+    VkImage                  image;
+    VkImageView              imageView;
+    VkBufferView             bufferView;
+    VkImageAspectFlagBits    plane;
+    MTLTexture_id            mtlTexture;
+} VkExportMetalTextureInfoEXT;
+
+typedef struct VkImportMetalTextureInfoEXT {
+    VkStructureType          sType;
+    const void*              pNext;
+    VkImageAspectFlagBits    plane;
+    MTLTexture_id            mtlTexture;
+} VkImportMetalTextureInfoEXT;
+
+typedef struct VkExportMetalIOSurfaceInfoEXT {
+    VkStructureType    sType;
+    const void*        pNext;
+    VkImage            image;
+    IOSurfaceRef       ioSurface;
+} VkExportMetalIOSurfaceInfoEXT;
+
+typedef struct VkImportMetalIOSurfaceInfoEXT {
+    VkStructureType    sType;
+    const void*        pNext;
+    IOSurfaceRef       ioSurface;
+} VkImportMetalIOSurfaceInfoEXT;
+
+typedef struct VkExportMetalSharedEventInfoEXT {
+    VkStructureType      sType;
+    const void*          pNext;
+    VkSemaphore          semaphore;
+    VkEvent              event;
+    MTLSharedEvent_id    mtlSharedEvent;
+} VkExportMetalSharedEventInfoEXT;
+
+typedef struct VkImportMetalSharedEventInfoEXT {
+    VkStructureType      sType;
+    const void*          pNext;
+    MTLSharedEvent_id    mtlSharedEvent;
+} VkImportMetalSharedEventInfoEXT;
+
+typedef void (VKAPI_PTR *PFN_vkExportMetalObjectsEXT)(VkDevice device, VkExportMetalObjectsInfoEXT* pMetalObjectsInfo);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR void VKAPI_CALL vkExportMetalObjectsEXT(
+    VkDevice                                    device,
+    VkExportMetalObjectsInfoEXT*                pMetalObjectsInfo);
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
--- a/src/include/vulkan/vulkan_raii.hpp
+++ b/src/include/vulkan/vulkan_raii.hpp
--- a/src/include/vulkan/vulkan_screen.h
+++ b/src/include/vulkan/vulkan_screen.h
@@ -0,0 +1,54 @@
+#ifndef VULKAN_SCREEN_H_
+#define VULKAN_SCREEN_H_ 1
+
+/*
+** Copyright 2015-2022 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_QNX_screen_surface 1
+#define VK_QNX_SCREEN_SURFACE_SPEC_VERSION 1
+#define VK_QNX_SCREEN_SURFACE_EXTENSION_NAME "VK_QNX_screen_surface"
+typedef VkFlags VkScreenSurfaceCreateFlagsQNX;
+typedef struct VkScreenSurfaceCreateInfoQNX {
+    VkStructureType                  sType;
+    const void*                      pNext;
+    VkScreenSurfaceCreateFlagsQNX    flags;
+    struct _screen_context*          context;
+    struct _screen_window*           window;
+} VkScreenSurfaceCreateInfoQNX;
+
+typedef VkResult (VKAPI_PTR *PFN_vkCreateScreenSurfaceQNX)(VkInstance instance, const VkScreenSurfaceCreateInfoQNX* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface);
+typedef VkBool32 (VKAPI_PTR *PFN_vkGetPhysicalDeviceScreenPresentationSupportQNX)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, struct _screen_window* window);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR VkResult VKAPI_CALL vkCreateScreenSurfaceQNX(
+    VkInstance                                  instance,
+    const VkScreenSurfaceCreateInfoQNX*         pCreateInfo,
+    const VkAllocationCallbacks*                pAllocator,
+    VkSurfaceKHR*                               pSurface);
+
+VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceScreenPresentationSupportQNX(
+    VkPhysicalDevice                            physicalDevice,
+    uint32_t                                    queueFamilyIndex,
+    struct _screen_window*                      window);
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
--- a/src/include/vulkan/vulkan_structs.hpp
+++ b/src/include/vulkan/vulkan_structs.hpp
--- a/src/include/vulkan/vulkan_vi.h
+++ b/src/include/vulkan/vulkan_vi.h
@@ -0,0 +1,47 @@
+#ifndef VULKAN_VI_H_
+#define VULKAN_VI_H_ 1
+
+/*
+** Copyright 2015-2022 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_NN_vi_surface 1
+#define VK_NN_VI_SURFACE_SPEC_VERSION     1
+#define VK_NN_VI_SURFACE_EXTENSION_NAME   "VK_NN_vi_surface"
+typedef VkFlags VkViSurfaceCreateFlagsNN;
+typedef struct VkViSurfaceCreateInfoNN {
+    VkStructureType             sType;
+    const void*                 pNext;
+    VkViSurfaceCreateFlagsNN    flags;
+    void*                       window;
+} VkViSurfaceCreateInfoNN;
+
+typedef VkResult (VKAPI_PTR *PFN_vkCreateViSurfaceNN)(VkInstance instance, const VkViSurfaceCreateInfoNN* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR VkResult VKAPI_CALL vkCreateViSurfaceNN(
+    VkInstance                                  instance,
+    const VkViSurfaceCreateInfoNN*              pCreateInfo,
+    const VkAllocationCallbacks*                pAllocator,
+    VkSurfaceKHR*                               pSurface);
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
--- a/src/include/vulkan/vulkan_wayland.h
+++ b/src/include/vulkan/vulkan_wayland.h
@@ -0,0 +1,54 @@
+#ifndef VULKAN_WAYLAND_H_
+#define VULKAN_WAYLAND_H_ 1
+
+/*
+** Copyright 2015-2022 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_wayland_surface 1
+#define VK_KHR_WAYLAND_SURFACE_SPEC_VERSION 6
+#define VK_KHR_WAYLAND_SURFACE_EXTENSION_NAME "VK_KHR_wayland_surface"
+typedef VkFlags VkWaylandSurfaceCreateFlagsKHR;
+typedef struct VkWaylandSurfaceCreateInfoKHR {
+    VkStructureType                   sType;
+    const void*                       pNext;
+    VkWaylandSurfaceCreateFlagsKHR    flags;
+    struct wl_display*                display;
+    struct wl_surface*                surface;
+} VkWaylandSurfaceCreateInfoKHR;
+
+typedef VkResult (VKAPI_PTR *PFN_vkCreateWaylandSurfaceKHR)(VkInstance instance, const VkWaylandSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface);
+typedef VkBool32 (VKAPI_PTR *PFN_vkGetPhysicalDeviceWaylandPresentationSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, struct wl_display* display);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR VkResult VKAPI_CALL vkCreateWaylandSurfaceKHR(
+    VkInstance                                  instance,
+    const VkWaylandSurfaceCreateInfoKHR*        pCreateInfo,
+    const VkAllocationCallbacks*                pAllocator,
+    VkSurfaceKHR*                               pSurface);
+
+VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceWaylandPresentationSupportKHR(
+    VkPhysicalDevice                            physicalDevice,
+    uint32_t                                    queueFamilyIndex,
+    struct wl_display*                          display);
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
--- a/src/include/vulkan/vulkan_win32.h
+++ b/src/include/vulkan/vulkan_win32.h
@@ -0,0 +1,315 @@
+#ifndef VULKAN_WIN32_H_
+#define VULKAN_WIN32_H_ 1
+
+/*
+** Copyright 2015-2022 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
--- a/src/include/vulkan/vulkan_xcb.h
+++ b/src/include/vulkan/vulkan_xcb.h
@@ -0,0 +1,55 @@
+#ifndef VULKAN_XCB_H_
+#define VULKAN_XCB_H_ 1
+
+/*
+** Copyright 2015-2022 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_xcb_surface 1
+#define VK_KHR_XCB_SURFACE_SPEC_VERSION   6
+#define VK_KHR_XCB_SURFACE_EXTENSION_NAME "VK_KHR_xcb_surface"
+typedef VkFlags VkXcbSurfaceCreateFlagsKHR;
+typedef struct VkXcbSurfaceCreateInfoKHR {
+    VkStructureType               sType;
+    const void*                   pNext;
+    VkXcbSurfaceCreateFlagsKHR    flags;
+    xcb_connection_t*             connection;
+    xcb_window_t                  window;
+} VkXcbSurfaceCreateInfoKHR;
+
+typedef VkResult (VKAPI_PTR *PFN_vkCreateXcbSurfaceKHR)(VkInstance instance, const VkXcbSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface);
+typedef VkBool32 (VKAPI_PTR *PFN_vkGetPhysicalDeviceXcbPresentationSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, xcb_connection_t* connection, xcb_visualid_t visual_id);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR VkResult VKAPI_CALL vkCreateXcbSurfaceKHR(
+    VkInstance                                  instance,
+    const VkXcbSurfaceCreateInfoKHR*            pCreateInfo,
+    const VkAllocationCallbacks*                pAllocator,
+    VkSurfaceKHR*                               pSurface);
+
+VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceXcbPresentationSupportKHR(
+    VkPhysicalDevice                            physicalDevice,
+    uint32_t                                    queueFamilyIndex,
+    xcb_connection_t*                           connection,
+    xcb_visualid_t                              visual_id);
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
--- a/src/include/vulkan/vulkan_xlib.h
+++ b/src/include/vulkan/vulkan_xlib.h
@@ -0,0 +1,55 @@
+#ifndef VULKAN_XLIB_H_
+#define VULKAN_XLIB_H_ 1
+
+/*
+** Copyright 2015-2022 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_xlib_surface 1
+#define VK_KHR_XLIB_SURFACE_SPEC_VERSION  6
+#define VK_KHR_XLIB_SURFACE_EXTENSION_NAME "VK_KHR_xlib_surface"
+typedef VkFlags VkXlibSurfaceCreateFlagsKHR;
+typedef struct VkXlibSurfaceCreateInfoKHR {
+    VkStructureType                sType;
+    const void*                    pNext;
+    VkXlibSurfaceCreateFlagsKHR    flags;
+    Display*                       dpy;
+    Window                         window;
+} VkXlibSurfaceCreateInfoKHR;
+
+typedef VkResult (VKAPI_PTR *PFN_vkCreateXlibSurfaceKHR)(VkInstance instance, const VkXlibSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface);
+typedef VkBool32 (VKAPI_PTR *PFN_vkGetPhysicalDeviceXlibPresentationSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, Display* dpy, VisualID visualID);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR VkResult VKAPI_CALL vkCreateXlibSurfaceKHR(
+    VkInstance                                  instance,
+    const VkXlibSurfaceCreateInfoKHR*           pCreateInfo,
+    const VkAllocationCallbacks*                pAllocator,
+    VkSurfaceKHR*                               pSurface);
+
+VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceXlibPresentationSupportKHR(
+    VkPhysicalDevice                            physicalDevice,
+    uint32_t                                    queueFamilyIndex,
+    Display*                                    dpy,
+    VisualID                                    visualID);
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
--- a/src/include/vulkan/vulkan_xlib_xrandr.h
+++ b/src/include/vulkan/vulkan_xlib_xrandr.h
@@ -0,0 +1,45 @@
+#ifndef VULKAN_XLIB_XRANDR_H_
+#define VULKAN_XLIB_XRANDR_H_ 1
+
+/*
+** Copyright 2015-2022 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_acquire_xlib_display 1
+#define VK_EXT_ACQUIRE_XLIB_DISPLAY_SPEC_VERSION 1
+#define VK_EXT_ACQUIRE_XLIB_DISPLAY_EXTENSION_NAME "VK_EXT_acquire_xlib_display"
+typedef VkResult (VKAPI_PTR *PFN_vkAcquireXlibDisplayEXT)(VkPhysicalDevice physicalDevice, Display* dpy, VkDisplayKHR display);
+typedef VkResult (VKAPI_PTR *PFN_vkGetRandROutputDisplayEXT)(VkPhysicalDevice physicalDevice, Display* dpy, RROutput rrOutput, VkDisplayKHR* pDisplay);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR VkResult VKAPI_CALL vkAcquireXlibDisplayEXT(
+    VkPhysicalDevice                            physicalDevice,
+    Display*                                    dpy,
+    VkDisplayKHR                                display);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkGetRandROutputDisplayEXT(
+    VkPhysicalDevice                            physicalDevice,
+    Display*                                    dpy,
+    RROutput                                    rrOutput,
+    VkDisplayKHR*                               pDisplay);
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
--- a/src/include_make/86box/version.h
+++ b/src/include_make/86box/version.h
@@ -20,11 +20,11 @@
 #define EMU_NAME	"86Box"
 #define EMU_NAME_W	LSTR(EMU_NAME)

-#define EMU_VERSION	"3.5"
+#define EMU_VERSION	"3.6"
 #define EMU_VERSION_W	LSTR(EMU_VERSION)
-#define EMU_VERSION_EX	"3.50"
+#define EMU_VERSION_EX	"3.50" /* frozen due to IDE re-detection behavior on Windows */
 #define EMU_VERSION_MAJ	3
-#define EMU_VERSION_MIN	5
+#define EMU_VERSION_MIN	6
 #define EMU_VERSION_PATCH 0

 #define EMU_BUILD_NUM	0
@@ -40,7 +40,7 @@
 #define EMU_ROMS_URL	"https://github.com/86Box/roms/releases/latest"
 #define EMU_ROMS_URL_W	LSTR(EMU_ROMS_URL)
 #ifdef RELEASE_BUILD
-# define EMU_DOCS_URL	"https://86box.readthedocs.io/en/v3.5/"
+# define EMU_DOCS_URL	"https://86box.readthedocs.io/en/v3.6/"
 #else
 # define EMU_DOCS_URL	"https://86box.readthedocs.io"
 #endif
--- a/src/machine/machine.c
+++ b/src/machine/machine.c
@@ -118,6 +118,8 @@ machine_init_ex(int m)
        if (ibm8514_enabled) {
            ibm8514_device_add();
        }
+        if (xga_enabled)
+            xga_device_add();
    }

    /* Reset the graphics card (or do nothing if it was already done
--- a/src/qt/CMakeLists.txt
+++ b/src/qt/CMakeLists.txt
@@ -179,7 +179,8 @@ if(WIN32)
    enable_language(RC)
    target_sources(86Box PUBLIC ../win/86Box-qt.rc)
    target_sources(plat PRIVATE win_joystick_rawinput.c)
-    target_link_libraries(86Box hid)
+    target_sources(ui PRIVATE qt_d3d9renderer.hpp qt_d3d9renderer.cpp)
+    target_link_libraries(86Box hid d3d9)

    # CMake 3.22 messed this up for clang/clang++
    # See https://gitlab.kitware.com/cmake/cmake/-/issues/22611
@@ -239,12 +240,24 @@ if(WIN32)
        # needed for static builds
        qt_import_plugins(plat INCLUDE Qt${QT_MAJOR}::QWindowsIntegrationPlugin Qt${QT_MAJOR}::QICOPlugin Qt${QT_MAJOR}::QWindowsVistaStylePlugin)
    else()
-        install(CODE "
-            get_filename_component(CMAKE_INSTALL_PREFIX_ABSOLUTE \${CMAKE_INSTALL_PREFIX} ABSOLUTE)
-            execute_process(
-                COMMAND $<TARGET_FILE:Qt${QT_MAJOR}::windeployqt>
-                \"\${CMAKE_INSTALL_PREFIX_ABSOLUTE}/$<TARGET_FILE_NAME:86Box>\")
-        ")
+        if(USE_QT6)
+            install(CODE "
+                get_filename_component(CMAKE_INSTALL_PREFIX_ABSOLUTE \${CMAKE_INSTALL_PREFIX} ABSOLUTE)
+                execute_process(
+                    COMMAND $<TARGET_FILE:Qt${QT_MAJOR}::windeployqt>
+                    \"\${CMAKE_INSTALL_PREFIX_ABSOLUTE}/$<TARGET_FILE_NAME:86Box>\")
+            ")
+        else()
+            find_program(WINDEPLOYQT_EXECUTABLE windeployqt)
+            if(WINDEPLOYQT_EXECUTABLE)
+                install(CODE "
+                    get_filename_component(CMAKE_INSTALL_PREFIX_ABSOLUTE \${CMAKE_INSTALL_PREFIX} ABSOLUTE)
+                    execute_process(
+                        COMMAND ${WINDEPLOYQT_EXECUTABLE}
+                        \"\${CMAKE_INSTALL_PREFIX_ABSOLUTE}/$<TARGET_FILE_NAME:86Box>\")
+                ")
+            endif()
+        endif()
    endif()
 endif()

--- a/src/qt/qt.c
+++ b/src/qt/qt.c
@@ -49,6 +49,8 @@ plat_vidapi(char* api) {
        return 3;
    } else if (!strcasecmp(api, "qt_vulkan")) {
        return 4;
+    } else if (!strcasecmp(api, "qt_d3d9")) {
+        return 5;
    }

    return 0;
@@ -73,6 +75,9 @@ char* plat_vidapi_name(int api) {
    case 4:
        name = "qt_vulkan";
        break;
+    case 5:
+        name = "qt_d3d9";
+        break;
    default:
        fatal("Unknown renderer: %i\n", api);
        break;
--- a/src/qt/qt_d3d9renderer.cpp
+++ b/src/qt/qt_d3d9renderer.cpp
@@ -0,0 +1,167 @@
+#include "qt_d3d9renderer.hpp"
+#include <QResizeEvent>
+#include <QTimer>
+
+extern "C"
+{
+#include <86box/86box.h>
+#include <86box/video.h>
+}
+
+D3D9Renderer::D3D9Renderer(QWidget *parent)
+    : QWidget{parent}, RendererCommon()
+{
+    QPalette pal = palette();
+    pal.setColor(QPalette::Window, Qt::black);
+    setAutoFillBackground(true);
+    setPalette(pal);
+
+    setAttribute(Qt::WA_NativeWindow);
+    setAttribute(Qt::WA_PaintOnScreen);
+    setAttribute(Qt::WA_NoSystemBackground);
+    setAttribute(Qt::WA_OpaquePaintEvent);
+
+    windowHandle = (HWND)winId();
+    surfaceInUse = true;
+
+    RendererCommon::parentWidget = parent;
+
+    this->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
+}
+
+D3D9Renderer::~D3D9Renderer()
+{
+    finalize();
+}
+
+void D3D9Renderer::finalize()
+{
+    if (!finalized) {
+        while (surfaceInUse) {}
+        finalized = true;
+    }
+    surfaceInUse = true;
+    if (d3d9surface) { d3d9surface->Release(); d3d9surface = nullptr;}
+    if (d3d9dev) { d3d9dev->Release(); d3d9dev = nullptr; }
+    if (d3d9) { d3d9->Release(); d3d9 = nullptr; };
+}
+
+void D3D9Renderer::hideEvent(QHideEvent *event)
+{
+    finalize();
+}
+
+void D3D9Renderer::showEvent(QShowEvent *event)
+{
+    params = {};
+
+    if (FAILED(Direct3DCreate9Ex(D3D_SDK_VERSION, &d3d9))) {
+        return error("Failed to create Direct3D 9 context");
+    }
+
+    params.Windowed                   = true;
+    params.SwapEffect                 = D3DSWAPEFFECT_FLIPEX;
+    params.BackBufferWidth            = width() * devicePixelRatioF();
+    params.BackBufferHeight           = height() * devicePixelRatioF();
+    params.BackBufferCount            = 1;
+    params.FullScreen_RefreshRateInHz = D3DPRESENT_RATE_DEFAULT;
+    params.PresentationInterval       = D3DPRESENT_INTERVAL_IMMEDIATE;
+    params.hDeviceWindow              = windowHandle;
+
+    HRESULT result = d3d9->CreateDeviceEx(D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, windowHandle, D3DCREATE_MULTITHREADED | D3DCREATE_HARDWARE_VERTEXPROCESSING, &params, nullptr, &d3d9dev);
+    if (FAILED(result)) result = d3d9->CreateDeviceEx(D3DADAPTER_DEFAULT, D3DDEVTYPE_REF, windowHandle, D3DCREATE_MULTITHREADED | D3DCREATE_SOFTWARE_VERTEXPROCESSING, &params, nullptr, &d3d9dev);
+    if (FAILED(result)) {
+        return error("Failed to create Direct3D 9 device");
+    }
+
+    result = d3d9dev->CreateOffscreenPlainSurface(2048, 2048, D3DFMT_A8R8G8B8, D3DPOOL_DEFAULT, &d3d9surface, nullptr);
+    if (FAILED(result)) result = d3d9dev->CreateOffscreenPlainSurface(1024, 1024, D3DFMT_A8R8G8B8, D3DPOOL_DEFAULT, &d3d9surface, nullptr);
+    if (FAILED(result)) {
+        return error("Failed to create Direct3D 9 surface");
+    }
+    if (!alreadyInitialized) {
+        emit initialized();
+        alreadyInitialized = true;
+    }
+    surfaceInUse = false;
+    finalized = false;
+}
+
+void D3D9Renderer::paintEvent(QPaintEvent *event)
+{
+    IDirect3DSurface9* backbuffer = nullptr;
+    RECT srcRect, dstRect;
+    HRESULT result = d3d9dev->GetBackBuffer(0, 0, D3DBACKBUFFER_TYPE_MONO, &backbuffer);
+
+    if (FAILED(result)) {
+        return;
+    }
+
+    srcRect.top = source.top();
+    srcRect.bottom = source.bottom();
+    srcRect.left = source.left();
+    srcRect.right = source.right();
+    dstRect.top = destination.top();
+    dstRect.bottom = destination.bottom();
+    dstRect.left = destination.left();
+    dstRect.right = destination.right();
+    d3d9dev->BeginScene();
+    while (surfaceInUse) {}
+    surfaceInUse = true;
+    d3d9dev->StretchRect(d3d9surface, &srcRect, backbuffer, &dstRect, video_filter_method == 0 ? D3DTEXF_POINT : D3DTEXF_LINEAR);
+    result = d3d9dev->EndScene();
+    surfaceInUse = false;
+    if (SUCCEEDED(result)) {
+        if (FAILED(d3d9dev->PresentEx(nullptr, nullptr, 0, nullptr, 0))) {
+            finalize();
+            showEvent(nullptr);
+        }
+    }
+}
+
+bool D3D9Renderer::event(QEvent *event)
+{
+    bool res = false;
+    if (!eventDelegate(event, res)) return QWidget::event(event);
+    return res;
+}
+
+void D3D9Renderer::resizeEvent(QResizeEvent *event)
+{
+    onResize(event->size().width() * devicePixelRatioF(), event->size().height() * devicePixelRatioF());
+
+    params.BackBufferWidth = event->size().width() * devicePixelRatioF();
+    params.BackBufferHeight = event->size().height() * devicePixelRatioF();
+    if (d3d9dev) d3d9dev->Reset(&params);
+    QWidget::resizeEvent(event);
+}
+
+void D3D9Renderer::blit(int x, int y, int w, int h)
+{
+    if ((x < 0) || (y < 0) || (w <= 0) || (h <= 0) || (w > 2048) || (h > 2048) || (buffer32 == NULL) || surfaceInUse) {
+        video_blit_complete();
+        return;
+    }
+    surfaceInUse = true;
+    source.setRect(x, y, w, h);
+    RECT srcRect;
+    D3DLOCKED_RECT lockRect;
+    srcRect.top = source.top();
+    srcRect.bottom = source.bottom();
+    srcRect.left = source.left();
+    srcRect.right = source.right();
+
+    if (screenshots) {
+        video_screenshot((uint32_t *) &(buffer32->line[y][x]), 0, 0, 2048);
+    }
+    if (SUCCEEDED(d3d9surface->LockRect(&lockRect, &srcRect, 0))) {
+        for (int y1 = 0; y1 < h; y1++) {
+            video_copy(((uint8_t*)lockRect.pBits) + (y1 * lockRect.Pitch), &(buffer32->line[y + y1][x]), w * 4);
+        }
+        video_blit_complete();
+        d3d9surface->UnlockRect();
+    }
+    else video_blit_complete();
+    surfaceInUse = false;
+    QTimer::singleShot(0, this, [this] { this->update(); });
+}
--- a/src/qt/qt_d3d9renderer.hpp
+++ b/src/qt/qt_d3d9renderer.hpp
@@ -0,0 +1,44 @@
+#ifndef D3D9RENDERER_HPP
+#define D3D9RENDERER_HPP
+
+#include <QWidget>
+#include "qt_renderercommon.hpp"
+
+#include <windows.h>
+#include <d3d9.h>
+#include <atomic>
+
+class D3D9Renderer : public QWidget, public RendererCommon
+{
+    Q_OBJECT
+public:
+    explicit D3D9Renderer(QWidget *parent = nullptr);
+    ~D3D9Renderer();
+    bool hasBlitFunc() override { return true; }
+    void blit(int x, int y, int w, int h) override;
+    void finalize() override;
+
+protected:
+    void showEvent(QShowEvent* event) override;
+    void hideEvent(QHideEvent *event) override;
+    void resizeEvent(QResizeEvent *event) override;
+    void paintEvent(QPaintEvent *event) override;
+    bool event(QEvent* event) override;
+    QPaintEngine* paintEngine() const override { return nullptr; }
+
+signals:
+    void initialized();
+    void error(QString);
+
+private:
+    HWND windowHandle = 0;
+    D3DPRESENT_PARAMETERS params{};
+    IDirect3D9Ex* d3d9 = nullptr;
+    IDirect3DDevice9Ex* d3d9dev = nullptr;
+    IDirect3DSurface9* d3d9surface = nullptr;
+
+    std::atomic<bool> surfaceInUse{false}, finalized{false};
+    bool alreadyInitialized = false;
+};
+
+#endif // D3D9RENDERER_HPP
--- a/src/qt/qt_machinestatus.cpp
+++ b/src/qt/qt_machinestatus.cpp
@@ -583,24 +583,25 @@ void MachineStatus::updateTip(int tag)
 {
    int category = tag & 0xfffffff0;
    int item = tag & 0xf;
+    if (!MediaMenu::ptr) return;
    switch (category) {
    case SB_CASSETTE:
-        d->cassette.label->setToolTip(MediaMenu::ptr->cassetteMenu->title());
+        if (d->cassette.label && MediaMenu::ptr->cassetteMenu) d->cassette.label->setToolTip(MediaMenu::ptr->cassetteMenu->title());
        break;
    case SB_CARTRIDGE:
-        d->cartridge[item].label->setToolTip(MediaMenu::ptr->cartridgeMenus[item]->title());
+        if (d->cartridge[item].label && MediaMenu::ptr->cartridgeMenus[item]) d->cartridge[item].label->setToolTip(MediaMenu::ptr->cartridgeMenus[item]->title());
        break;
    case SB_FLOPPY:
-        d->fdd[item].label->setToolTip(MediaMenu::ptr->floppyMenus[item]->title());
+        if (d->fdd[item].label && MediaMenu::ptr->floppyMenus[item]) d->fdd[item].label->setToolTip(MediaMenu::ptr->floppyMenus[item]->title());
        break;
    case SB_CDROM:
-        d->cdrom[item].label->setToolTip(MediaMenu::ptr->cdromMenus[item]->title());
+        if (d->cdrom[item].label && MediaMenu::ptr->cdromMenus[item]) d->cdrom[item].label->setToolTip(MediaMenu::ptr->cdromMenus[item]->title());
        break;
    case SB_ZIP:
-        d->zip[item].label->setToolTip(MediaMenu::ptr->zipMenus[item]->title());
+        if (d->zip[item].label && MediaMenu::ptr->zipMenus[item]) d->zip[item].label->setToolTip(MediaMenu::ptr->zipMenus[item]->title());
        break;
    case SB_MO:
-        d->mo[item].label->setToolTip(MediaMenu::ptr->moMenus[item]->title());
+        if (d->mo[item].label && MediaMenu::ptr->moMenus[item]) d->mo[item].label->setToolTip(MediaMenu::ptr->moMenus[item]->title());
        break;
    case SB_HDD:
        break;
--- a/src/qt/qt_main.cpp
+++ b/src/qt/qt_main.cpp
@@ -120,10 +120,7 @@ main_thread_fn()
            }
        } else {
            /* Just so we dont overload the host OS. */
-            if (drawits < -1 || dopause)
-                std::this_thread::sleep_for(std::chrono::milliseconds(1));
-            else
-                std::this_thread::yield();
+            std::this_thread::sleep_for(std::chrono::milliseconds(1));
        }

        /* If needed, handle a screen resize. */
--- a/src/qt/qt_mainwindow.cpp
+++ b/src/qt/qt_mainwindow.cpp
@@ -281,6 +281,10 @@ MainWindow::MainWindow(QWidget *parent) :
        ui->actionVulkan->setVisible(false);
        ui->actionOpenGL_3_0_Core->setVisible(false);
    }
+#if !defined Q_OS_WINDOWS
+    ui->actionDirect3D_9->setVisible(false);
+    if (vid_api == 5) vid_api = 0;
+#endif

 #if !QT_CONFIG(vulkan)
    if (vid_api == 4) vid_api = 0;
@@ -295,6 +299,7 @@ MainWindow::MainWindow(QWidget *parent) :
    actGroup->addAction(ui->actionHardware_Renderer_OpenGL_ES);
    actGroup->addAction(ui->actionOpenGL_3_0_Core);
    actGroup->addAction(ui->actionVulkan);
+    actGroup->addAction(ui->actionDirect3D_9);
    actGroup->setExclusive(true);

    connect(actGroup, &QActionGroup::triggered, [this](QAction* action) {
@@ -316,6 +321,9 @@ MainWindow::MainWindow(QWidget *parent) :
        case 4:
            ui->stackedWidget->switchRenderer(RendererStack::Renderer::Vulkan);
            break;
+        case 5:
+            ui->stackedWidget->switchRenderer(RendererStack::Renderer::Direct3D9);
+            break;
        }
    });

@@ -1341,6 +1349,7 @@ void MainWindow::processMacKeyboardInput(bool down, const QKeyEvent* event) {
 void MainWindow::on_actionFullscreen_triggered() {
    if (video_fullscreen > 0) {
        showNormal();
+        if (vid_api == 5) ui->stackedWidget->switchRenderer(RendererStack::Renderer::Direct3D9);
        ui->menubar->show();
        if (!hide_status_bar) ui->statusbar->show();
        if (!hide_tool_bar) ui->toolBar->show();
--- a/src/qt/qt_mainwindow.ui
+++ b/src/qt/qt_mainwindow.ui
@@ -54,7 +54,7 @@
     <x>0</x>
     <y>0</y>
     <width>724</width>
-     <height>23</height>
+     <height>21</height>
    </rect>
   </property>
   <widget class="QMenu" name="menuAction">
@@ -105,6 +105,7 @@
     <addaction name="actionHardware_Renderer_OpenGL_ES"/>
     <addaction name="actionOpenGL_3_0_Core"/>
     <addaction name="actionVulkan"/>
+     <addaction name="actionDirect3D_9"/>
    </widget>
    <widget class="QMenu" name="menuWindow_scale_factor">
     <property name="title">
@@ -745,6 +746,17 @@
    <string>MCA devices...</string>
   </property>
  </action>
+  <action name="actionDirect3D_9">
+   <property name="checkable">
+    <bool>true</bool>
+   </property>
+   <property name="text">
+    <string>Direct3D 9</string>
+   </property>
+   <property name="vid_api" stdset="0">
+    <number>5</number>
+   </property>
+  </action>
 </widget>
 <customwidgets>
  <customwidget>
--- a/src/qt/qt_mediamenu.cpp
+++ b/src/qt/qt_mediamenu.cpp
@@ -510,6 +510,7 @@ void MediaMenu::zipEject(int i) {
    zip_t *dev = (zip_t *) zip_drives[i].priv;

    zip_disk_close(dev);
+    zip_drives[i].image_path[0] = 0;
    if (zip_drives[i].bus_type) {
        /* Signal disk change to the emulated machine. */
        zip_insert(dev);
@@ -609,6 +610,7 @@ void MediaMenu::moEject(int i) {
    mo_t *dev = (mo_t *) mo_drives[i].priv;

    mo_disk_close(dev);
+    mo_drives[i].image_path[0] = 0;
    if (mo_drives[i].bus_type) {
        /* Signal disk change to the emulated machine. */
        mo_insert(dev);
--- a/src/qt/qt_renderercommon.hpp
+++ b/src/qt/qt_renderercommon.hpp
@@ -22,13 +22,16 @@ public:

    virtual uint32_t getBytesPerRow() { return 2048 * 4; }

-    virtual std::vector<std::tuple<uint8_t *, std::atomic_flag *>> getBuffers() = 0;
+    virtual std::vector<std::tuple<uint8_t *, std::atomic_flag *>> getBuffers() { std::vector<std::tuple<uint8_t*, std::atomic_flag*>> buffers; return buffers; }

    /* Does renderer implement options dialog */
    virtual bool hasOptions() const { return false; }
    /* Returns options dialog for renderer */
    virtual QDialog *getOptions(QWidget *parent) { return nullptr; }

+    virtual bool hasBlitFunc() { return false; }
+    virtual void blit(int x, int y, int w, int h) {}
+
 protected:
    bool eventDelegate(QEvent *event, bool &result);

--- a/src/qt/qt_rendererstack.cpp
+++ b/src/qt/qt_rendererstack.cpp
@@ -25,6 +25,9 @@
 #include "qt_openglrenderer.hpp"
 #include "qt_softwarerenderer.hpp"
 #include "qt_vulkanwindowrenderer.hpp"
+#ifdef Q_OS_WIN
+#include "qt_d3d9renderer.hpp"
+#endif

 #include "qt_mainwindow.hpp"
 #include "qt_util.hpp"
@@ -224,13 +227,27 @@ RendererStack::switchRenderer(Renderer renderer)
    startblit();
    if (current) {
        rendererWindow->finalize();
+        if (rendererWindow->hasBlitFunc()) {
+            while (directBlitting) {}
+            connect(this, &RendererStack::blit, this, &RendererStack::blitDummy, Qt::DirectConnection);
+            disconnect(this, &RendererStack::blit, this, &RendererStack::blitRenderer);
+        } else {
+            connect(this, &RendererStack::blit, this, &RendererStack::blitDummy, Qt::DirectConnection);
+            disconnect(this, &RendererStack::blit, this, &RendererStack::blitCommon);
+        }
+
        removeWidget(current.get());
        disconnect(this, &RendererStack::blitToRenderer, nullptr, nullptr);

        /* Create new renderer only after previous is destroyed! */
-        connect(current.get(), &QObject::destroyed, [this, renderer](QObject *) { createRenderer(renderer); });
+        connect(current.get(), &QObject::destroyed, [this, renderer](QObject *) {
+            createRenderer(renderer);
+            disconnect(this, &RendererStack::blit, this, &RendererStack::blitDummy);
+            blitDummied = false;
+            QTimer::singleShot(1000, this, [this]() { this->blitDummied = false; } );
+        });

-        current.release()->deleteLater();
+        rendererWindow->hasBlitFunc() ? current.reset() : current.release()->deleteLater();
    } else {
        createRenderer(renderer);
    }
@@ -292,6 +309,30 @@ RendererStack::createRenderer(Renderer renderer)
                current.reset(this->createWindowContainer(hw, this));
                break;
            }
+#ifdef Q_OS_WIN
+        case Renderer::Direct3D9:
+        {
+            this->createWinId();
+            auto hw = new D3D9Renderer(this);
+            rendererWindow = hw;
+            connect(hw, &D3D9Renderer::error, this, [this](QString str)
+            {
+                auto msgBox = new QMessageBox(QMessageBox::Critical, "86Box", QString("Failed to initialize D3D9 renderer. Falling back to software rendering.\n\n") + str, QMessageBox::Ok);
+                msgBox->setAttribute(Qt::WA_DeleteOnClose);
+                msgBox->show();
+                imagebufs = {};
+                endblit();
+                QTimer::singleShot(0, this, [this]() { switchRenderer(Renderer::Software); });
+            });
+            connect(hw, &D3D9Renderer::initialized, this, [this]()
+            {
+                endblit();
+                emit rendererChanged();
+            });
+            current.reset(hw);
+            break;
+        }
+#endif
 #if QT_CONFIG(vulkan)
        case Renderer::Vulkan:
        {
@@ -340,18 +381,41 @@ RendererStack::createRenderer(Renderer renderer)

    currentBuf = 0;

-    if (renderer != Renderer::OpenGL3 && renderer != Renderer::Vulkan) {
+    if (rendererWindow->hasBlitFunc()) {
+        connect(this, &RendererStack::blit, this, &RendererStack::blitRenderer, Qt::DirectConnection);
+    }
+    else {
+        connect(this, &RendererStack::blit, this, &RendererStack::blitCommon, Qt::DirectConnection);
+    }
+
+    if (renderer != Renderer::OpenGL3 && renderer != Renderer::Vulkan && renderer != Renderer::Direct3D9) {
        imagebufs = rendererWindow->getBuffers();
        endblit();
        emit rendererChanged();
    }
 }

+void
+RendererStack::blitDummy(int x, int y, int w, int h)
+{
+    video_blit_complete();
+    blitDummied = true;
+}
+
+void
+RendererStack::blitRenderer(int x, int y, int w, int h)
+{
+    if (blitDummied) { blitDummied = false; video_blit_complete(); return; }
+    directBlitting = true;
+    rendererWindow->blit(x, y, w, h);
+    directBlitting = false;
+}
+
 // called from blitter thread
 void
-RendererStack::blit(int x, int y, int w, int h)
+RendererStack::blitCommon(int x, int y, int w, int h)
 {
-    if ((x < 0) || (y < 0) || (w <= 0) || (h <= 0) || (w > 2048) || (h > 2048) || (buffer32 == NULL) || imagebufs.empty() || std::get<std::atomic_flag *>(imagebufs[currentBuf])->test_and_set()) {
+    if ((x < 0) || (y < 0) || (w <= 0) || (h <= 0) || (w > 2048) || (h > 2048) || (buffer32 == NULL) || imagebufs.empty() || std::get<std::atomic_flag *>(imagebufs[currentBuf])->test_and_set() || blitDummied) {
        video_blit_complete();
        return;
    }
--- a/src/qt/qt_rendererstack.hpp
+++ b/src/qt/qt_rendererstack.hpp
@@ -45,7 +45,8 @@ public:
        OpenGL,
        OpenGLES,
        OpenGL3,
-        Vulkan
+        Vulkan,
+        Direct3D9
    };
    void switchRenderer(Renderer renderer);

@@ -72,10 +73,13 @@ public:

 signals:
    void blitToRenderer(int buf_idx, int x, int y, int w, int h);
+    void blit(int x, int y, int w, int h);
    void rendererChanged();

 public slots:
-    void blit(int x, int y, int w, int h);
+    void blitCommon(int x, int y, int w, int h);
+    void blitRenderer(int x, int y, int w, int h);
+    void blitDummy(int x, int y, int w, int h);
    void mousePoll();

 private:
@@ -98,6 +102,7 @@ private:

    RendererCommon          *rendererWindow { nullptr };
    std::unique_ptr<QWidget> current;
+    std::atomic<bool> directBlitting{false}, blitDummied{false};
 };

 #endif // QT_RENDERERCONTAINER_HPP
--- a/src/qt/qt_settingsdisplay.cpp
+++ b/src/qt/qt_settingsdisplay.cpp
@@ -24,6 +24,7 @@ extern "C" {
 #include <86box/device.h>
 #include <86box/machine.h>
 #include <86box/video.h>
+#include <86box/vid_xga_device.h>
 }

 #include "qt_deviceconfig.hpp"
@@ -47,6 +48,7 @@ void SettingsDisplay::save() {
    gfxcard = ui->comboBoxVideo->currentData().toInt();
    voodoo_enabled = ui->checkBoxVoodoo->isChecked() ? 1 : 0;
    ibm8514_enabled = ui->checkBox8514->isChecked() ? 1 : 0;
+    xga_enabled = ui->checkBoxXga->isChecked() ? 1 : 0;
 }

 void SettingsDisplay::onCurrentMachineChanged(int machineId) {
@@ -101,6 +103,14 @@ void SettingsDisplay::on_pushButtonConfigureVoodoo_clicked() {
    DeviceConfig::ConfigureDevice(&voodoo_device, 0, qobject_cast<Settings*>(Settings::settings));
 }

+void SettingsDisplay::on_pushButtonConfigureXga_clicked() {
+    if (machine_has_bus(machineId, MACHINE_BUS_MCA) > 0) {
+        DeviceConfig::ConfigureDevice(&xga_device, 0, qobject_cast<Settings*>(Settings::settings));
+    } else {
+        DeviceConfig::ConfigureDevice(&xga_isa_device, 0, qobject_cast<Settings*>(Settings::settings));
+    }
+}
+
 void SettingsDisplay::on_comboBoxVideo_currentIndexChanged(int index) {
    if (index < 0) {
        return;
@@ -119,10 +129,20 @@ void SettingsDisplay::on_comboBoxVideo_currentIndexChanged(int index) {
    bool has_MCA = machine_has_bus(machineId, MACHINE_BUS_MCA) > 0;
    ui->checkBox8514->setEnabled(hasIsa16 || has_MCA);
    if (hasIsa16 || has_MCA) {
-        ui->checkBox8514->setChecked(ibm8514_enabled > 0);
+        ui->checkBox8514->setChecked(ibm8514_enabled);
    }
+
+    ui->checkBoxXga->setEnabled(hasIsa16 || has_MCA);
+    if (hasIsa16 || has_MCA)
+        ui->checkBoxXga->setChecked(xga_enabled);
+
+    ui->pushButtonConfigureXga->setEnabled((hasIsa16 || has_MCA) && ui->checkBoxXga->isChecked());
 }

 void SettingsDisplay::on_checkBoxVoodoo_stateChanged(int state) {
    ui->pushButtonConfigureVoodoo->setEnabled(state == Qt::Checked);
 }
+
+void SettingsDisplay::on_checkBoxXga_stateChanged(int state) {
+    ui->pushButtonConfigureXga->setEnabled(state == Qt::Checked);
+}
--- a/src/qt/qt_settingsdisplay.hpp
+++ b/src/qt/qt_settingsdisplay.hpp
@@ -22,8 +22,10 @@ public slots:

 private slots:
    void on_checkBoxVoodoo_stateChanged(int state);
+    void on_checkBoxXga_stateChanged(int state);
    void on_comboBoxVideo_currentIndexChanged(int index);
    void on_pushButtonConfigureVoodoo_clicked();
+    void on_pushButtonConfigureXga_clicked();
    void on_pushButtonConfigure_clicked();

 private:
--- a/src/qt/qt_settingsdisplay.ui
+++ b/src/qt/qt_settingsdisplay.ui
@@ -70,7 +70,21 @@
     </property>
    </widget>
   </item>
-   <item row="3" column="0">
+   <item row="3" column="2">
+    <widget class="QPushButton" name="pushButtonConfigureXga">
+     <property name="text">
+      <string>Configure</string>
+     </property>
+    </widget>
+   </item>
+   <item row="3" column="0" colspan="2">
+    <widget class="QCheckBox" name="checkBoxXga">
+     <property name="text">
+      <string>XGA</string>
+     </property>
+    </widget>
+   </item>
+   <item row="4" column="0">
    <spacer name="verticalSpacer">
     <property name="orientation">
      <enum>Qt::Vertical</enum>
--- a/src/scsi/scsi_ncr5380.c
+++ b/src/scsi/scsi_ncr5380.c
@@ -749,6 +749,11 @@ ncr_read(uint16_t port, void *priv)
 		break;

 	case 2:		/* Mode register */
+        if (((ncr->mode & 0x30) == 0x30) && ((ncr_dev->type == 1) && (ncr_dev->bios_ver == 1)))
+            ncr->mode = 0;
+		if (((ncr->mode & 0x20) == 0x20) && (ncr_dev->type == 0))
+            ncr->mode = 0;
+
 		ncr_log("Read: Mode register\n");
 		ret = ncr->mode;
 		break;
@@ -764,6 +769,10 @@ ncr_read(uint16_t port, void *priv)
 		ncr_bus_read(ncr_dev);
 		ncr_log("NCR cur bus stat=%02x\n", ncr->cur_bus & 0xff);
 		ret |= (ncr->cur_bus & 0xff);
+		if ((ncr->icr & ICR_SEL) && ((ncr_dev->type == 1) && (ncr_dev->bios_ver == 1)))
+            ret |= 0x02;
+        if ((ncr->icr & ICR_BSY) && ((ncr_dev->type == 1) && (ncr_dev->bios_ver == 1)))
+            ret |= 0x40;
 		break;

 	case 5:		/* Bus and Status register */
@@ -782,9 +791,9 @@ ncr_read(uint16_t port, void *priv)
 		ncr_bus_read(ncr_dev);
 		bus = ncr->cur_bus;

-		if (bus & BUS_ACK)
+		if ((bus & BUS_ACK) || ((ncr->icr & ICR_ACK) && ((ncr_dev->type == 1) && (ncr_dev->bios_ver == 1))))
 			ret |= STATUS_ACK;
-		if (bus & BUS_ATN)
+		if ((bus & BUS_ATN) || ((ncr->icr & ICR_ATN) && ((ncr_dev->type == 1) && (ncr_dev->bios_ver == 1))))
 			ret |= 0x02;

 		if ((bus & BUS_REQ) && (ncr->mode & MODE_DMA)) {
@@ -920,8 +929,6 @@ memio_write(uint32_t addr, uint8_t val, void *priv)

    addr &= 0x3fff;

-    ncr_log("memio_write(%08x,%02x)  %i %02x\n", addr, val,  ncr_dev->buffer_host_pos, ncr_dev->status_ctrl);
-
    if (addr >= 0x3a00)
 	ncr_dev->ext_ram[addr - 0x3a00] = val;
    else switch (addr & 0x3f80) {
--- a/src/unix/assets/86Box.spec
+++ b/src/unix/assets/86Box.spec
@@ -12,10 +12,10 @@
 # After a successful build, you can install the RPMs as follows:
 #  sudo dnf install RPMS/$(uname -m)/86Box-3* RPMS/noarch/86Box-roms*

-%global romver 20220523
+%global romver 20220701

 Name:		86Box
-Version:	3.5
+Version:	3.6
 Release:	1%{?dist}
 Summary:	Classic PC emulator
 License:	GPLv2+
@@ -120,5 +120,5 @@ popd
 %{_bindir}/roms

 %changelog
-* Mon May 23 2022 Robert de Rooy <robert.de.rooy[AT]gmail.com> 3.5-1
+* Fri Jul 01 2022 Robert de Rooy <robert.de.rooy[AT]gmail.com> 3.6-1
 - Bump release
--- a/src/unix/assets/net.86box.86Box.metainfo.xml
+++ b/src/unix/assets/net.86box.86Box.metainfo.xml
@@ -10,7 +10,7 @@
    </categories>
    <launchable type="desktop-id">net.86box.86Box.desktop</launchable>
    <releases>
-      <release version="3.5" date="2022-04-26"/>
+      <release version="3.6" date="2022-06-27"/>
    </releases>
    <content_rating type="oars-1.1" />
    <description>
--- a/src/video/CMakeLists.txt
+++ b/src/video/CMakeLists.txt
@@ -24,7 +24,8 @@ add_library(vid OBJECT agpgart.c video.c vid_table.c vid_cga.c vid_cga_comp.c
    vid_stg_ramdac.c vid_ht216.c vid_oak_oti.c vid_paradise.c vid_rtg310x.c
    vid_f82c425.c vid_ti_cf62011.c vid_tvga.c vid_tgui9440.c vid_tkd8001_ramdac.c
    vid_att20c49x_ramdac.c vid_s3.c vid_s3_virge.c vid_ibm_rgb528_ramdac.c
-    vid_sdac_ramdac.c vid_ogc.c vid_nga.c vid_tvp3026_ramdac.c vid_att2xc498_ramdac.c)
+    vid_sdac_ramdac.c vid_ogc.c vid_nga.c vid_tvp3026_ramdac.c vid_att2xc498_ramdac.c
+    vid_xga.c)

 if(MGA)
    target_compile_definitions(vid PRIVATE USE_MGA)
--- a/src/video/vid_8514a.c
+++ b/src/video/vid_8514a.c
--- a/src/video/vid_ega.c
+++ b/src/video/vid_ega.c
@@ -461,6 +461,8 @@ ega_recalctimings(ega_t *ega)
 	ega->dispontime = TIMER_USEC;
    if (ega->dispofftime < TIMER_USEC)
 	ega->dispofftime = TIMER_USEC;
+
+    ega_recalc_remap_func(ega);
 }


@@ -561,7 +563,7 @@ ega_poll(void *p)
 		}
 	}
 	ega->vc++;
-	ega->vc &= 1023;
+	ega->vc &= 511;
 	if (ega->vc == ega->split) {
 		if (ega->interlace && ega->oddeven)
 			ega->ma = ega->maback = ega->ma_latch + (ega->rowoffset << 1);
--- a/src/video/vid_ega_render.c
+++ b/src/video/vid_ega_render.c
@@ -27,6 +27,7 @@
 #include <86box/rom.h>
 #include <86box/video.h>
 #include <86box/vid_ega.h>
+#include <86box/vid_ega_render_remap.h>


 int
@@ -113,6 +114,7 @@ ega_render_text_40(ega_t *ega)
    uint8_t chr, attr, dat;
    uint32_t charaddr;
    int fg, bg;
+    uint32_t addr;

    if ((ega->displine + ega->y_add) < 0)
 	return;
@@ -126,27 +128,31 @@ ega_render_text_40(ega_t *ega)
 	xinc = (ega->seqregs[1] & 1) ? 16 : 18;

 	for (x = 0; x < (ega->hdisp + ega->scrollcache); x += xinc) {
+        addr = ega->remap_func(ega, ega->ma) & ega->vrammask;
+
 		drawcursor = ((ega->ma == ega->ca) && ega->con && ega->cursoron);

 		if (ega->crtc[0x17] & 0x80) {
-			chr  = ega->vram[(ega->ma << 1) & ega->vrammask];
-			attr = ega->vram[((ega->ma << 1) + 1) & ega->vrammask];
+			chr  = ega->vram[addr];
+			attr = ega->vram[addr + 1];
 		} else
 			chr = attr = 0;

-		if (attr & 8)	charaddr = ega->charsetb + (chr * 128);
-		else		charaddr = ega->charseta + (chr * 128);
+		if (attr & 8)
+            charaddr = ega->charsetb + ((chr * 0x80));
+		else
+            charaddr = ega->charseta + ((chr * 0x80));

 		if (drawcursor) {
-			bg = ega->pallook[ega->egapal[attr & 15]];
+			bg = ega->pallook[ega->egapal[attr & 0x0f]];
 			fg = ega->pallook[ega->egapal[attr >> 4]];
 		} else {
-			fg = ega->pallook[ega->egapal[attr & 15]];
+			fg = ega->pallook[ega->egapal[attr & 0x0f]];
 			bg = ega->pallook[ega->egapal[attr >> 4]];

-			if (attr & 0x80 && ega->attrregs[0x10] & 8) {
+			if ((attr & 0x80) && ega->attrregs[0x10] & 8) {
 				bg = ega->pallook[ega->egapal[(attr >> 4) & 7]];
-				if (ega->blink & 16)
+				if (ega->blink & 0x10)
 					fg = bg;
 			}
 		}
@@ -180,6 +186,7 @@ ega_render_text_80(ega_t *ega)
    uint8_t chr, attr, dat;
    uint32_t charaddr;
    int fg, bg;
+    uint32_t addr;

    if ((ega->displine + ega->y_add) < 0)
 	return;
@@ -189,50 +196,54 @@ ega_render_text_80(ega_t *ega)
    ega->lastline_draw = ega->displine;

    if (fullchange) {
-	p = &buffer32->line[ega->displine + ega->y_add][ega->x_add];
-	xinc = (ega->seqregs[1] & 1) ? 8 : 9;
+        p = &buffer32->line[ega->displine + ega->y_add][ega->x_add];
+        xinc = (ega->seqregs[1] & 1) ? 8 : 9;

-	for (x = 0; x < (ega->hdisp + ega->scrollcache); x += xinc) {
-		drawcursor = ((ega->ma == ega->ca) && ega->con && ega->cursoron);
+        for (x = 0; x < (ega->hdisp + ega->scrollcache); x += xinc) {
+            addr = ega->remap_func(ega, ega->ma) & ega->vrammask;

-		if (ega->crtc[0x17] & 0x80) {
-			chr  = ega->vram[(ega->ma << 1) & ega->vrammask];
-			attr = ega->vram[((ega->ma << 1) + 1) & ega->vrammask];
-		} else
-			chr = attr = 0;
+            drawcursor = ((ega->ma == ega->ca) && ega->con && ega->cursoron);

-		if (attr & 8)	charaddr = ega->charsetb + (chr * 128);
-		else		charaddr = ega->charseta + (chr * 128);
+            if (ega->crtc[0x17] & 0x80) {
+				chr  = ega->vram[addr];
+				attr = ega->vram[addr + 1];
+            } else
+                chr = attr = 0;

-		if (drawcursor) {
-			bg = ega->pallook[ega->egapal[attr & 15]];
-			fg = ega->pallook[ega->egapal[attr >> 4]];
-		} else {
-			fg = ega->pallook[ega->egapal[attr & 15]];
-			bg = ega->pallook[ega->egapal[attr >> 4]];
-			if (attr & 0x80 && ega->attrregs[0x10] & 8) {
-				bg = ega->pallook[ega->egapal[(attr >> 4) & 7]];
-				if (ega->blink & 16)
-					fg = bg;
-			}
-		}
+            if (attr & 0x08)
+                charaddr = ega->charsetb + (chr * 0x80);
+            else
+                charaddr = ega->charseta + (chr * 0x80);

-		dat = ega->vram[charaddr + (ega->sc << 2)];
-		if (ega->seqregs[1] & 1)  {
-			for (xx = 0; xx < 8; xx++)
-				p[xx] = (dat & (0x80 >> xx)) ? fg : bg;
-		} else {
-			for (xx = 0; xx < 8; xx++)
-				p[xx] = (dat & (0x80 >> xx)) ? fg : bg;
-			if ((chr & ~0x1F) != 0xC0 || !(ega->attrregs[0x10] & 4))
-				p[8] = bg;
-			else
-				p[8] = (dat & 1) ? fg : bg;
-		}
-		ega->ma += 4;
-		p += xinc;
-	}
-	ega->ma &= ega->vrammask;
+            if (drawcursor) {
+                bg = ega->pallook[ega->egapal[attr & 0x0f]];
+                fg = ega->pallook[ega->egapal[attr >> 4]];
+            } else {
+                fg = ega->pallook[ega->egapal[attr & 0x0f]];
+                bg = ega->pallook[ega->egapal[attr >> 4]];
+                if ((attr & 0x80) && ega->attrregs[0x10] & 8) {
+                    bg = ega->pallook[ega->egapal[(attr >> 4) & 7]];
+                    if (ega->blink & 16)
+                        fg = bg;
+                }
+            }
+
+            dat = ega->vram[charaddr + (ega->sc << 2)];
+            if (ega->seqregs[1] & 1)  {
+                for (xx = 0; xx < 8; xx++)
+                    p[xx] = (dat & (0x80 >> xx)) ? fg : bg;
+            } else {
+                for (xx = 0; xx < 8; xx++)
+                    p[xx] = (dat & (0x80 >> xx)) ? fg : bg;
+                if ((chr & ~0x1F) != 0xC0 || !(ega->attrregs[0x10] & 4))
+                    p[8] = bg;
+                else
+                    p[8] = (dat & 1) ? fg : bg;
+            }
+            ega->ma += 4;
+            p += xinc;
+        }
+        ega->ma &= ega->vrammask;
    }
 }

@@ -250,51 +261,34 @@ ega_render_2bpp_lowres(ega_t *ega)
    p = &buffer32->line[ega->displine + ega->y_add][ega->x_add];

    if (ega->firstline_draw == 2000)
-	ega->firstline_draw = ega->displine;
+        ega->firstline_draw = ega->displine;
    ega->lastline_draw = ega->displine;

    for (x = 0; x <= (ega->hdisp + ega->scrollcache); x += 16) {
-	addr = ega->ma;
+        addr = ega->remap_func(ega, ega->ma);

-	if (!(ega->crtc[0x17] & 0x40)) {
-		addr = (addr << 1) & ega->vrammask;
-		addr &= ~7;
+        dat[0] = ega->vram[addr];
+        dat[1] = ega->vram[addr | 0x1];
+        if (ega->seqregs[1] & 4)
+            ega->ma += 2;
+        else
+            ega->ma += 4;

-		if ((ega->crtc[0x17] & 0x20) && (ega->ma & 0x20000))
-			addr |= 4;
+        ega->ma &= ega->vrammask;

-		if (!(ega->crtc[0x17] & 0x20) && (ega->ma & 0x8000))
-			addr |= 4;
-	}
+        if (ega->crtc[0x17] & 0x80) {
+            p[0]  = p[1]  = ega->pallook[ega->egapal[(dat[0] >> 6) & 3]];
+            p[2]  = p[3]  = ega->pallook[ega->egapal[(dat[0] >> 4) & 3]];
+            p[4]  = p[5]  = ega->pallook[ega->egapal[(dat[0] >> 2) & 3]];
+            p[6]  = p[7]  = ega->pallook[ega->egapal[dat[0] & 3]];
+            p[8]  = p[9]  = ega->pallook[ega->egapal[(dat[1] >> 6) & 3]];
+            p[10] = p[11] = ega->pallook[ega->egapal[(dat[1] >> 4) & 3]];
+            p[12] = p[13] = ega->pallook[ega->egapal[(dat[1] >> 2) & 3]];
+            p[14] = p[15] = ega->pallook[ega->egapal[dat[1] & 3]];
+        } else
+            memset(p, 0x00, 16 * sizeof(uint32_t));

-	if (!(ega->crtc[0x17] & 0x01))
-		addr = (addr & ~0x8000) | ((ega->sc & 1) ? 0x8000 : 0);
-
-	if (!(ega->crtc[0x17] & 0x02))
-		addr = (addr & ~0x10000) | ((ega->sc & 2) ? 0x10000 : 0);
-
-	dat[0] = ega->vram[addr];
-	dat[1] = ega->vram[addr | 0x1];
-	if (ega->seqregs[1] & 4)
-		ega->ma += 2;
-	else
-		ega->ma += 4;
-
-	ega->ma &= ega->vrammask;
-
-	if (ega->crtc[0x17] & 0x80) {
-		p[0]  = p[1]  = ega->pallook[ega->egapal[(dat[0] >> 6) & 3]];
-		p[2]  = p[3]  = ega->pallook[ega->egapal[(dat[0] >> 4) & 3]];
-		p[4]  = p[5]  = ega->pallook[ega->egapal[(dat[0] >> 2) & 3]];
-		p[6]  = p[7]  = ega->pallook[ega->egapal[dat[0] & 3]];
-		p[8]  = p[9]  = ega->pallook[ega->egapal[(dat[1] >> 6) & 3]];
-		p[10] = p[11] = ega->pallook[ega->egapal[(dat[1] >> 4) & 3]];
-		p[12] = p[13] = ega->pallook[ega->egapal[(dat[1] >> 2) & 3]];
-		p[14] = p[15] = ega->pallook[ega->egapal[dat[1] & 3]];
-	} else
-		memset(p, 0x00, 16 * sizeof(uint32_t));
-
-	p += 16;
+        p += 16;
    }
 }

@@ -312,51 +306,34 @@ ega_render_2bpp_highres(ega_t *ega)
    p = &buffer32->line[ega->displine + ega->y_add][ega->x_add];

    if (ega->firstline_draw == 2000)
-	ega->firstline_draw = ega->displine;
+        ega->firstline_draw = ega->displine;
    ega->lastline_draw = ega->displine;

    for (x = 0; x <= (ega->hdisp + ega->scrollcache); x += 8) {
-	addr = ega->ma;
+        addr = ega->remap_func(ega, ega->ma);

-	if (!(ega->crtc[0x17] & 0x40)) {
-		addr = (addr << 1) & ega->vrammask;
-		addr &= ~7;
+        dat[0] = ega->vram[addr];
+        dat[1] = ega->vram[addr | 0x1];
+        if (ega->seqregs[1] & 4)
+            ega->ma += 2;
+        else
+            ega->ma += 4;

-		if ((ega->crtc[0x17] & 0x20) && (ega->ma & 0x20000))
-			addr |= 4;
+        ega->ma &= ega->vrammask;

-		if (!(ega->crtc[0x17] & 0x20) && (ega->ma & 0x8000))
-			addr |= 4;
-	}
+        if (ega->crtc[0x17] & 0x80) {
+            p[0] = ega->pallook[ega->egapal[(dat[0] >> 6) & 3]];
+            p[1] = ega->pallook[ega->egapal[(dat[0] >> 4) & 3]];
+            p[2] = ega->pallook[ega->egapal[(dat[0] >> 2) & 3]];
+            p[3] = ega->pallook[ega->egapal[dat[0] & 3]];
+            p[4] = ega->pallook[ega->egapal[(dat[1] >> 6) & 3]];
+            p[5] = ega->pallook[ega->egapal[(dat[1] >> 4) & 3]];
+            p[6] = ega->pallook[ega->egapal[(dat[1] >> 2) & 3]];
+            p[7] = ega->pallook[ega->egapal[dat[1] & 3]];
+        } else
+            memset(p, 0x00, 8 * sizeof(uint32_t));

-	if (!(ega->crtc[0x17] & 0x01))
-		addr = (addr & ~0x8000) | ((ega->sc & 1) ? 0x8000 : 0);
-
-	if (!(ega->crtc[0x17] & 0x02))
-		addr = (addr & ~0x10000) | ((ega->sc & 2) ? 0x10000 : 0);
-
-	dat[0] = ega->vram[addr];
-	dat[1] = ega->vram[addr | 0x1];
-	if (ega->seqregs[1] & 4)
-		ega->ma += 2;
-	else
-		ega->ma += 4;
-
-	ega->ma &= ega->vrammask;
-
-	if (ega->crtc[0x17] & 0x80) {
-		p[0]  = ega->pallook[ega->egapal[(dat[0] >> 6) & 3]];
-		p[1]  = ega->pallook[ega->egapal[(dat[0] >> 4) & 3]];
-		p[2]  = ega->pallook[ega->egapal[(dat[0] >> 2) & 3]];
-		p[3]  = ega->pallook[ega->egapal[dat[0] & 3]];
-		p[4]  = ega->pallook[ega->egapal[(dat[1] >> 6) & 3]];
-		p[5] = ega->pallook[ega->egapal[(dat[1] >> 4) & 3]];
-		p[6] = ega->pallook[ega->egapal[(dat[1] >> 2) & 3]];
-		p[7] = ega->pallook[ega->egapal[dat[1] & 3]];
-	} else
-		memset(p, 0x00, 8 * sizeof(uint32_t));
-
-	p += 8;
+        p += 8;
    }
 }

@@ -374,65 +351,42 @@ ega_render_4bpp_lowres(ega_t *ega)
    p = &buffer32->line[ega->displine + ega->y_add][ega->x_add];

    if (ega->firstline_draw == 2000)
-	ega->firstline_draw = ega->displine;
+        ega->firstline_draw = ega->displine;
    ega->lastline_draw = ega->displine;

    for (x = 0; x <= (ega->hdisp + ega->scrollcache); x += 16) {
-	addr = ega->ma;
-	oddeven = 0;
+        addr = ega->remap_func(ega, ega->ma);
+        oddeven = 0;

-	if (!(ega->crtc[0x17] & 0x40)) {
-		addr = (addr << 1) & ega->vrammask;
+        if (ega->seqregs[1] & 4) {
+            oddeven = (addr & 4) ? 1 : 0;
+            edat[0] = ega->vram[addr | oddeven];
+            edat[2] = ega->vram[addr | oddeven | 0x2];
+                edat[1] = edat[3] = 0;
+            ega->ma += 2;
+        } else {
+            *(uint32_t *)(&edat[0]) = *(uint32_t *)(&ega->vram[addr]);
+            ega->ma += 4;
+        }
+        ega->ma &= ega->vrammask;

-		if (ega->seqregs[1] & 4)
-			oddeven = (addr & 4) ? 1 : 0;
+        if (ega->crtc[0x17] & 0x80) {
+            dat = edatlookup[edat[0] >> 6][edat[1] >> 6] | (edatlookup[edat[2] >> 6][edat[3] >> 6] << 2);
+            p[0]  = p[1]  = ega->pallook[ega->egapal[(dat >> 4) & ega->plane_mask]];
+            p[2]  = p[3]  = ega->pallook[ega->egapal[dat & ega->plane_mask]];
+            dat = edatlookup[(edat[0] >> 4) & 3][(edat[1] >> 4) & 3] | (edatlookup[(edat[2] >> 4) & 3][(edat[3] >> 4) & 3] << 2);
+            p[4]  = p[5]  = ega->pallook[ega->egapal[(dat >> 4) & ega->plane_mask]];
+            p[6]  = p[7]  = ega->pallook[ega->egapal[dat & ega->plane_mask]];
+            dat = edatlookup[(edat[0] >> 2) & 3][(edat[1] >> 2) & 3] | (edatlookup[(edat[2] >> 2) & 3][(edat[3] >> 2) & 3] << 2);
+            p[8]  = p[9]  = ega->pallook[ega->egapal[(dat >> 4) & ega->plane_mask]];
+            p[10] = p[11] = ega->pallook[ega->egapal[dat & ega->plane_mask]];
+            dat = edatlookup[edat[0] & 3][edat[1] & 3] | (edatlookup[edat[2] & 3][edat[3] & 3] << 2);
+            p[12] = p[13] = ega->pallook[ega->egapal[(dat >> 4) & ega->plane_mask]];
+            p[14] = p[15] = ega->pallook[ega->egapal[dat & ega->plane_mask]];
+        } else
+            memset(p, 0x00, 16 * sizeof(uint32_t));

-		addr &= ~7;
-
-		if ((ega->crtc[0x17] & 0x20) && (ega->ma & 0x20000))
-			addr |= 4;
-		if (!(ega->crtc[0x17] & 0x20) && (ega->ma & 0x8000))
-			addr |= 4;
-	}
-
-	if (!(ega->crtc[0x17] & 0x01))
-		addr = (addr & ~0x8000) | ((ega->sc & 1) ? 0x8000 : 0);
-
-	if (!(ega->crtc[0x17] & 0x02))
-		addr = (addr & ~0x10000) | ((ega->sc & 2) ? 0x10000 : 0);
-
-	if (ega->seqregs[1] & 4) {
-		edat[0] = ega->vram[addr | oddeven];
-		edat[2] = ega->vram[addr | oddeven | 0x2];
-		edat[1] = edat[3] = 0;
-		ega->ma += 2;
-	} else {
-		edat[0] = ega->vram[addr];
-		edat[1] = ega->vram[addr | 0x1];
-		edat[2] = ega->vram[addr | 0x2];
-		edat[3] = ega->vram[addr | 0x3];
-		ega->ma += 4;
-	}
-
-	ega->ma &= ega->vrammask;
-
-	if (ega->crtc[0x17] & 0x80) {
-		dat = edatlookup[edat[0] >> 6][edat[1] >> 6] | (edatlookup[edat[2] >> 6][edat[3] >> 6] << 2);
-		p[0]  = p[1]  = ega->pallook[ega->egapal[(dat >> 4) & ega->plane_mask]];
-		p[2]  = p[3]  = ega->pallook[ega->egapal[dat & ega->plane_mask]];
-		dat = edatlookup[(edat[0] >> 4) & 3][(edat[1] >> 4) & 3] | (edatlookup[(edat[2] >> 4) & 3][(edat[3] >> 4) & 3] << 2);
-		p[4]  = p[5]  = ega->pallook[ega->egapal[(dat >> 4) & ega->plane_mask]];
-		p[6]  = p[7]  = ega->pallook[ega->egapal[dat & ega->plane_mask]];
-		dat = edatlookup[(edat[0] >> 2) & 3][(edat[1] >> 2) & 3] | (edatlookup[(edat[2] >> 2) & 3][(edat[3] >> 2) & 3] << 2);
-		p[8]  = p[9]  = ega->pallook[ega->egapal[(dat >> 4) & ega->plane_mask]];
-		p[10] = p[11] = ega->pallook[ega->egapal[dat & ega->plane_mask]];
-		dat = edatlookup[edat[0] & 3][edat[1] & 3] | (edatlookup[edat[2] & 3][edat[3] & 3] << 2);
-		p[12] = p[13] = ega->pallook[ega->egapal[(dat >> 4) & ega->plane_mask]];
-		p[14] = p[15] = ega->pallook[ega->egapal[dat & ega->plane_mask]];
-	} else
-		memset(p, 0x00, 16 * sizeof(uint32_t));
-
-	p += 16;
+        p += 16;
    }
 }

@@ -450,59 +404,41 @@ ega_render_4bpp_highres(ega_t *ega)
    p = &buffer32->line[ega->displine + ega->y_add][ega->x_add];

    if (ega->firstline_draw == 2000)
-	ega->firstline_draw = ega->displine;
+        ega->firstline_draw = ega->displine;
    ega->lastline_draw = ega->displine;

    for (x = 0; x <= (ega->hdisp + ega->scrollcache); x += 8) {
-	addr = ega->ma;
-	oddeven = 0;
+        addr = ega->remap_func(ega, ega->ma);
+        oddeven = 0;

-	if (!(ega->crtc[0x17] & 0x40)) {
-		addr = (addr << 1) & ega->vrammask;
+        if (ega->seqregs[1] & 4) {
+            oddeven = (addr & 4) ? 1 : 0;
+            edat[0] = ega->vram[addr | oddeven];
+            edat[2] = ega->vram[addr | oddeven | 0x2];
+                edat[1] = edat[3] = 0;
+            ega->ma += 2;
+        } else {
+            *(uint32_t *)(&edat[0]) = *(uint32_t *)(&ega->vram[addr]);
+            ega->ma += 4;
+        }
+        ega->ma &= ega->vrammask;

-		if (ega->seqregs[1] & 4)
-			oddeven = (addr & 4) ? 1 : 0;
+        if (ega->crtc[0x17] & 0x80) {
+            dat = edatlookup[edat[0] >> 6][edat[1] >> 6] | (edatlookup[edat[2] >> 6][edat[3] >> 6] << 2);
+            p[0] = ega->pallook[ega->egapal[(dat >> 4) & ega->plane_mask]];
+            p[1] = ega->pallook[ega->egapal[dat & ega->plane_mask]];
+            dat = edatlookup[(edat[0] >> 4) & 3][(edat[1] >> 4) & 3] | (edatlookup[(edat[2] >> 4) & 3][(edat[3] >> 4) & 3] << 2);
+            p[2] = ega->pallook[ega->egapal[(dat >> 4) & ega->plane_mask]];
+            p[3] = ega->pallook[ega->egapal[dat & ega->plane_mask]];
+            dat = edatlookup[(edat[0] >> 2) & 3][(edat[1] >> 2) & 3] | (edatlookup[(edat[2] >> 2) & 3][(edat[3] >> 2) & 3] << 2);
+            p[4] = ega->pallook[ega->egapal[(dat >> 4) & ega->plane_mask]];
+            p[5] = ega->pallook[ega->egapal[dat & ega->plane_mask]];
+            dat = edatlookup[edat[0] & 3][edat[1] & 3] | (edatlookup[edat[2] & 3][edat[3] & 3] << 2);
+            p[6] = ega->pallook[ega->egapal[(dat >> 4) & ega->plane_mask]];
+            p[7] = ega->pallook[ega->egapal[dat & ega->plane_mask]];
+        } else
+            memset(p, 0x00, 8 * sizeof(uint32_t));

-		addr &= ~7;
-
-		if ((ega->crtc[0x17] & 0x20) && (ega->ma & 0x20000))
-			addr |= 4;
-		if (!(ega->crtc[0x17] & 0x20) && (ega->ma & 0x8000))
-			addr |= 4;
-	}
-
-	if (!(ega->crtc[0x17] & 0x01))
-		addr = (addr & ~0x8000) | ((ega->sc & 1) ? 0x8000 : 0);
-	if (!(ega->crtc[0x17] & 0x02))
-		addr = (addr & ~0x10000) | ((ega->sc & 2) ? 0x10000 : 0);
-
-	if (ega->seqregs[1] & 4) {
-		edat[0] = ega->vram[addr | oddeven];
-		edat[2] = ega->vram[addr | oddeven | 0x2];
-		edat[1] = edat[3] = 0;
-		ega->ma += 2;
-	} else {
-		*(uint32_t *)(&edat[0]) = *(uint32_t *)(&ega->vram[addr]);
-		ega->ma += 4;
-	}
-	ega->ma &= ega->vrammask;
-
-	if (ega->crtc[0x17] & 0x80) {
-		dat = edatlookup[edat[0] >> 6][edat[1] >> 6] | (edatlookup[edat[2] >> 6][edat[3] >> 6] << 2);
-		p[0] = ega->pallook[ega->egapal[(dat >> 4) & ega->plane_mask]];
-		p[1] = ega->pallook[ega->egapal[dat & ega->plane_mask]];
-		dat = edatlookup[(edat[0] >> 4) & 3][(edat[1] >> 4) & 3] | (edatlookup[(edat[2] >> 4) & 3][(edat[3] >> 4) & 3] << 2);
-		p[2] = ega->pallook[ega->egapal[(dat >> 4) & ega->plane_mask]];
-		p[3] = ega->pallook[ega->egapal[dat & ega->plane_mask]];
-		dat = edatlookup[(edat[0] >> 2) & 3][(edat[1] >> 2) & 3] | (edatlookup[(edat[2] >> 2) & 3][(edat[3] >> 2) & 3] << 2);
-		p[4] = ega->pallook[ega->egapal[(dat >> 4) & ega->plane_mask]];
-		p[5] = ega->pallook[ega->egapal[dat & ega->plane_mask]];
-		dat = edatlookup[edat[0] & 3][edat[1] & 3] | (edatlookup[edat[2] & 3][edat[3] & 3] << 2);
-		p[6] = ega->pallook[ega->egapal[(dat >> 4) & ega->plane_mask]];
-		p[7] = ega->pallook[ega->egapal[dat & ega->plane_mask]];
-	} else
-		memset(p, 0x00, 8 * sizeof(uint32_t));
-
-	p += 8;
+        p += 8;
    }
 }
--- a/src/video/vid_s3.c
+++ b/src/video/vid_s3.c
@@ -3128,6 +3128,10 @@ static void s3_recalctimings(svga_t *svga)
 			if (s3->width == 1280 || s3->width == 1600 || (s3->card_type == S3_SPEA_MERCURY_P64V ||
 				s3->card_type == S3_NUMBER9_9FX_771))
 				svga->hdisp <<= 1;
+            if (s3->card_type == S3_NUMBER9_9FX_771) {
+                if (svga->hdisp == 832)
+                    svga->hdisp -= 32;
+            }
 			if (s3->card_type == S3_MIROVIDEO40SV_ERGO_968 || s3->card_type == S3_MIROCRYSTAL20SV_964 ||
 				s3->card_type == S3_MIROCRYSTAL20SD_864 || s3->card_type == S3_PHOENIX_VISION968 ||
 				s3->card_type == S3_SPEA_MERCURY_P64V) {
@@ -3378,12 +3382,9 @@ s3_updatemapping(s3_t *s3)

 				mem_mapping_set_addr(&s3->linear_mapping, s3->linear_base, s3->linear_size);
 			}
-			if (s3->chip >= S3_TRIO64V)
-				svga->fb_only = 1;
+			svga->fb_only = 1;
 		} else {
-			if (s3->chip >= S3_TRIO64V)
-				svga->fb_only = 0;
-
+			svga->fb_only = 0;
 			mem_mapping_disable(&s3->linear_mapping);
 		}

--- a/src/video/vid_s3_virge.c
+++ b/src/video/vid_s3_virge.c
@@ -777,7 +777,6 @@ static void s3_virge_recalctimings(svga_t *svga)

        if ((svga->crtc[0x67] & 0xc) != 0xc) /*VGA mode*/
        {
-				svga->fb_only = 0;
                svga->ma_latch |= (virge->ma_ext << 16);
                if (svga->crtc[0x51] & 0x30)      svga->rowoffset += (svga->crtc[0x51] & 0x30) << 4;
                else if (svga->crtc[0x43] & 0x04) svga->rowoffset += 0x100;
@@ -820,8 +819,6 @@ static void s3_virge_recalctimings(svga_t *svga)
        }
        else /*Streams mode*/
        {
-				svga->fb_only = 1;
-
                if (virge->streams.buffer_ctrl & 1)
                        svga->ma_latch = virge->streams.pri_fb1 >> 2;
                else
--- a/src/video/vid_svga.c
+++ b/src/video/vid_svga.c
@@ -9,7 +9,7 @@
 *		Generic SVGA handling.
 *
 *		This is intended to be used by another SVGA driver,
- *		and not as a card in it's own right.
+ *		and not as a card in its own right.
 *
 *
 *
@@ -40,7 +40,6 @@
 #include <86box/vid_svga.h>
 #include <86box/vid_svga_render.h>

-
 void svga_doblit(int wx, int wy, svga_t *svga);

 svga_t *svga_8514;
@@ -48,12 +47,12 @@ svga_t *svga_8514;
 extern int	cyc_total;
 extern uint8_t	edatlookup[4][4];

-uint8_t		svga_rotate[8][256];
+uint8_t svga_rotate[8][256];

 /*Primary SVGA device. As multiple video cards are not yet supported this is the
  only SVGA device.*/
-static svga_t	*svga_pri;
-int vga_on;
+static svga_t *svga_pri;
+int vga_on, ibm8514_on;

 svga_t
 *svga_get_pri()
@@ -559,7 +558,10 @@ svga_recalctimings(svga_t *svga)
            svga->recalctimings_ex(svga);
        }
    } else {
-        ibm8514_recalctimings(svga);
+        if (ibm8514_on && ibm8514_enabled)
+            ibm8514_recalctimings(svga);
+        if (xga_enabled)
+            xga_recalctimings(svga);
    }

    svga->y_add = (overscan_y >> 1) - (svga->crtc[8] & 0x1f);
@@ -657,9 +659,12 @@ svga_poll(void *p)
    int wx, wy;
    int ret, old_ma;

-    if (!vga_on) {
+    if (!vga_on && ibm8514_enabled && ibm8514_on) {
        ibm8514_poll(&svga->dev8514, svga);
        return;
+    } else if (!vga_on && xga_enabled && svga->xga.on) {
+        xga_poll(&svga->xga, svga);
+        return;
    }

    if (!svga->linepos) {
@@ -710,7 +715,7 @@ svga_poll(void *p)

 		if (svga->hwcursor_on || svga->dac_hwcursor_on || svga->overlay_on) {
 			svga->changedvram[svga->ma >> 12] = svga->changedvram[(svga->ma >> 12) + 1] =
-							    svga->interlace ? 3 : 2;
+                                svga->interlace ? 3 : 2;
 		}

 		if (svga->vertical_linedbl) {
@@ -956,7 +961,7 @@ svga_init(const device_t *info, svga_t *svga, void *p, int memsize,
    svga->decode_mask = 0x7fffff;
    svga->changedvram = calloc(memsize >> 12, 1);
    svga->recalctimings_ex = recalctimings_ex;
-    svga->video_in  = video_in;
+    svga->video_in = video_in;
    svga->video_out = video_out;
    svga->hwcursor_draw = hwcursor_draw;
    svga->overlay_draw = overlay_draw;
@@ -991,11 +996,6 @@ svga_init(const device_t *info, svga_t *svga, void *p, int memsize,

    svga_pri = svga;

-    if (ibm8514_enabled)
-        svga_8514 = svga;
-    else
-        svga_8514 = NULL;
-
    svga->ramdac_type = RAMDAC_6BIT;

    svga->map8 = svga->pallook;
@@ -1075,6 +1075,23 @@ svga_write_common(uint32_t addr, uint8_t val, uint8_t linear, void *p)
    cycles -= video_timing_write_b;

    if (!linear) {
+	if (xga_enabled) {
+        if (((svga->xga.op_mode & 7) >= 4) && (svga->xga.aperture_cntl == 1)) {
+            if (val == 0xa5) { /*Memory size test of XGA*/
+                svga->xga.test = val;
+                return;
+            } else if (val == 0x5a) {
+                svga->xga.test = val;
+                return;
+            } else if (val == 0x12 || val == 0x34) {
+                addr += svga->xga.write_bank;
+                svga->xga.vram[addr & svga->xga.vram_mask] = val;
+                svga->xga.linear_endian_reverse = 1;
+                return;
+            }
+        } else
+            svga->xga.on = 0;
+	}
 	addr = svga_decode_addr(svga, addr, 1);

 	if (addr == 0xffffffff)
@@ -1259,6 +1276,21 @@ svga_read_common(uint32_t addr, uint8_t linear, void *p)
    cycles -= video_timing_read_b;

    if (!linear) {
+	if (xga_enabled) {
+        if (((svga->xga.op_mode & 7) >= 4) && (svga->xga.aperture_cntl == 1)) {
+            if (svga->xga.test == 0xa5) { /*Memory size test of XGA*/
+                svga->xga.on = 1;
+                return svga->xga.test;
+            } else if (svga->xga.test == 0x5a) {
+                svga->xga.on = 1;
+                return svga->xga.test;
+            } else if (addr == 0xa0000 || addr == 0xa0010) {
+                addr += svga->xga.read_bank;
+                return svga->xga.vram[addr & svga->xga.vram_mask];
+            }
+        } else
+            svga->xga.on = 0;
+	}
 	addr = svga_decode_addr(svga, addr, 0);

 	if (addr == 0xffffffff)
--- a/src/video/vid_xga.c
+++ b/src/video/vid_xga.c
--- a/src/win/Makefile.mingw
+++ b/src/win/Makefile.mingw
@@ -71,7 +71,7 @@ ifeq ($(DEV_BUILD), y)
  OPEN_AT	:= y
 endif
 ifndef PAS16
-  PAS16		:= n
+  PAS16		:= y
 endif
 ifndef SIO_DETECT
  SIO_DETECT	:= y
@@ -173,14 +173,17 @@ endif
 ifndef DINPUT
 DINPUT		:= n
 endif
+ifndef FAUDIO
+ FAUDIO		:= n
+endif
 ifndef OPENAL
-OPENAL		:= n
+ OPENAL		:= n
 endif
 ifndef FLUIDSYNTH
-FLUIDSYNTH	:= y
+ FLUIDSYNTH	:= y
 endif
 ifndef MUNT
-MUNT		:= y
+ MUNT		:= y
 endif
 ifndef VNC
 VNC		:= n
@@ -715,7 +718,8 @@ VIDOBJ		:= agpgart.o video.o \
 		    vid_ibm_rgb528_ramdac.o vid_sdac_ramdac.o \
 			vid_ogc.o \
 			vid_nga.o \
-			vid_tvp3026_ramdac.o
+			vid_tvp3026_ramdac.o \
+			vid_xga.o

 VOODOOOBJ	:= vid_voodoo.o vid_voodoo_banshee.o \
 		    vid_voodoo_banshee_blitter.o \
@@ -746,6 +750,9 @@ endif
 ifeq ($(OPENAL), y)
 SNDOBJ		+= openal.o
 else
+ ifeq ($(FAUDIO), y)
+  OPTS		+= -DUSE_FAUDIO
+ endif
 SNDOBJ		+= xaudio2.o
 endif

@@ -757,7 +764,11 @@ ifdef EXOBJ
 OBJ		+= $(EXOBJ)
 endif

+ifeq ($(OPENAL), y)
+LIBS		:= -mwindows -lopenal -lcomctl32 -lSDL2 -limagehlp -ldinput8 -ldxguid -ldxerr8 -luser32 -lgdi32 -lwinmm -limm32 -lole32 -loleaut32 -lshell32 -lversion -luuid
+else
 LIBS		:= -mwindows -lcomctl32 -lSDL2 -limagehlp -ldinput8 -ldxguid -ldxerr8 -luser32 -lgdi32 -lwinmm -limm32 -lole32 -loleaut32 -lshell32 -lversion -luuid
+endif

 ifeq ($(RTMIDI), y)
 SNDOBJ		+= midi_rtmidi.o
--- a/src/win/languages/cs-CZ.rc
+++ b/src/win/languages/cs-CZ.rc
@@ -273,6 +273,7 @@ END
 #define STR_VIDEO		"Grafika:"
 #define STR_VOODOO		"Použít grafický akcelerátor Voodoo"
 #define STR_IBM8514		"IBM 8514/a Graphics"
+#define STR_XGA			"XGA Graphics"

 #define STR_MOUSE		"Myš:"
 #define STR_JOYSTICK		"Joystick:"
--- a/src/win/languages/de-DE.rc
+++ b/src/win/languages/de-DE.rc
@@ -273,6 +273,7 @@ END
 #define STR_VIDEO		"Videokarte:"
 #define STR_VOODOO		"Voodoo-Grafik"
 #define STR_IBM8514		"IBM 8514/a Graphics"
+#define STR_XGA			"XGA Graphics"

 #define STR_MOUSE		"Maus:"
 #define STR_JOYSTICK		"Joystick:"
--- a/src/win/languages/dialogs.rc
+++ b/src/win/languages/dialogs.rc
@@ -269,6 +269,12 @@ BEGIN
    CONTROL         STR_IBM8514, IDC_CHECK_IBM8514,
                    "Button", BS_AUTOCHECKBOX | WS_TABSTOP,
                    7, 46, 199, CFG_CHECKBOX_HEIGHT
+
+    CONTROL         STR_XGA, IDC_CHECK_XGA,
+                    "Button", BS_AUTOCHECKBOX | WS_TABSTOP,
+                    7, 65, 199, CFG_CHECKBOX_HEIGHT
+    PUSHBUTTON      STR_CONFIGURE, IDC_BUTTON_XGA,
+                    CFG_COMBO_BTN_LEFT, 64, CFG_BTN_WIDTH, CFG_BTN_HEIGHT
 END

 DLG_CFG_INPUT DIALOG DISCARDABLE  CFG_PANE_LEFT, CFG_PANE_TOP, CFG_PANE_WIDTH, CFG_PANE_HEIGHT
--- a/src/win/languages/en-GB.rc
+++ b/src/win/languages/en-GB.rc
@@ -273,6 +273,7 @@ END
 #define STR_VIDEO		"Video:"
 #define STR_VOODOO		"Voodoo Graphics"
 #define STR_IBM8514		"IBM 8514/a Graphics"
+#define STR_XGA			"XGA Graphics"

 #define STR_MOUSE		"Mouse:"
 #define STR_JOYSTICK		"Joystick:"
--- a/src/win/languages/en-US.rc
+++ b/src/win/languages/en-US.rc
@@ -273,6 +273,7 @@ END
 #define STR_VIDEO		"Video:"
 #define STR_VOODOO		"Voodoo Graphics"
 #define STR_IBM8514		"IBM 8514/a Graphics"
+#define STR_XGA			"XGA Graphics"

 #define STR_MOUSE		"Mouse:"
 #define STR_JOYSTICK		"Joystick:"
--- a/src/win/languages/es-ES.rc
+++ b/src/win/languages/es-ES.rc
@@ -273,6 +273,7 @@ END
 #define STR_VIDEO		"Vídeo:"
 #define STR_VOODOO		"Voodoo Graphics"
 #define STR_IBM8514		"IBM 8514/a Graphics"
+#define STR_XGA			"XGA Graphics"

 #define STR_MOUSE		"Ratón:"
 #define STR_JOYSTICK		"Mando:"
--- a/src/win/languages/fi-FI.rc
+++ b/src/win/languages/fi-FI.rc
@@ -273,6 +273,7 @@ END
 #define STR_VIDEO           "Näytönohjain:"
 #define STR_VOODOO          "Voodoo-grafiikkasuoritin"
 #define STR_IBM8514	        "IBM 8514/a Graphics"
+#define STR_XGA			"XGA Graphics"

 #define STR_MOUSE           "Hiiri:"
 #define STR_JOYSTICK        "Peliohjain:"
--- a/src/win/languages/fr-FR.rc
+++ b/src/win/languages/fr-FR.rc
@@ -273,6 +273,7 @@ END
 #define STR_VIDEO		"Vidéo:"
 #define STR_VOODOO		"Graphique Voodoo"
 #define STR_IBM8514		"IBM 8514/a Graphics"
+#define STR_XGA			"XGA Graphics"

 #define STR_MOUSE		"Souris:"
 #define STR_JOYSTICK		"Manette de commande:"
--- a/src/win/languages/hr-HR.rc
+++ b/src/win/languages/hr-HR.rc
@@ -273,6 +273,7 @@ END
 #define STR_VIDEO		"Video:"
 #define STR_VOODOO		"Voodoo grafika"
 #define STR_IBM8514		"IBM 8514/a Graphics"
+#define STR_XGA			"XGA Graphics"

 #define STR_MOUSE		"Miš:"
 #define STR_JOYSTICK		"Palica za igru:"
--- a/src/win/languages/hu-HU.rc
+++ b/src/win/languages/hu-HU.rc
@@ -278,6 +278,7 @@ END
 #define STR_VIDEO		"Videokártya:"
 #define STR_VOODOO		"Voodoo-gyorsítókártya"
 #define STR_IBM8514		"IBM 8514/a Graphics"
+#define STR_XGA			"XGA Graphics"

 #define STR_MOUSE		"Egér:"
 #define STR_JOYSTICK		"Játékvezérlő:"
--- a/src/win/languages/it-IT.rc
+++ b/src/win/languages/it-IT.rc
@@ -274,6 +274,7 @@ END
 #define STR_VIDEO		"Video:"
 #define STR_VOODOO		"Grafica Voodoo"
 #define STR_IBM8514		"IBM 8514/a Graphics"
+#define STR_XGA			"XGA Graphics"

 #define STR_MOUSE		"Mouse:"
 #define STR_JOYSTICK		"Joystick:"
--- a/src/win/languages/ja-JP.rc
+++ b/src/win/languages/ja-JP.rc
@@ -273,6 +273,7 @@ END
 #define STR_VIDEO		"ビデオカード:"
 #define STR_VOODOO		"Voodooグラフィック"
 #define STR_IBM8514		"IBM 8514/a Graphics"
+#define STR_XGA			"XGA Graphics"

 #define STR_MOUSE		"マウス:"
 #define STR_JOYSTICK		"ジョイスティック:"
--- a/src/win/languages/ko-KR.rc
+++ b/src/win/languages/ko-KR.rc
@@ -273,6 +273,7 @@ END
 #define STR_VIDEO		"비디오 카드:"
 #define STR_VOODOO		"Voodoo 그래픽"
 #define STR_IBM8514		"IBM 8514/a Graphics"
+#define STR_XGA			"XGA Graphics"

 #define STR_MOUSE		"마우스:"
 #define STR_JOYSTICK		"조이스틱:"
--- a/src/win/languages/pl-PL.rc
+++ b/src/win/languages/pl-PL.rc
@@ -273,6 +273,7 @@ END
 #define STR_VIDEO		"Wideo:"
 #define STR_VOODOO		"Grafika Voodoo"
 #define STR_IBM8514		"IBM 8514/a Graphics"
+#define STR_XGA			"XGA Graphics"

 #define STR_MOUSE		"Mysz:"
 #define STR_JOYSTICK		"Joystick:"
--- a/src/win/languages/pt-BR.rc
+++ b/src/win/languages/pt-BR.rc
@@ -276,6 +276,7 @@ END
 #define STR_VIDEO		"Vídeo:"
 #define STR_VOODOO		"3DFX Voodoo"
 #define STR_IBM8514		"IBM 8514/a Graphics"
+#define STR_XGA			"XGA Graphics"

 #define STR_MOUSE		"Mouse:"
 #define STR_JOYSTICK		"Joystick:"
--- a/src/win/languages/pt-PT.rc
+++ b/src/win/languages/pt-PT.rc
@@ -273,6 +273,7 @@ END
 #define STR_VIDEO		"Vídeo:"
 #define STR_VOODOO		"Gráficos Voodoo"
 #define STR_IBM8514		"IBM 8514/a Graphics"
+#define STR_XGA			"XGA Graphics"

 #define STR_MOUSE		"Rato:"
 #define STR_JOYSTICK		"Joystick:"
--- a/src/win/languages/ru-RU.rc
+++ b/src/win/languages/ru-RU.rc
@@ -273,6 +273,7 @@ END
 #define STR_VIDEO		"Видеокарта:"
 #define STR_VOODOO		"Ускоритель Voodoo"
 #define STR_IBM8514		"IBM 8514/a Graphics"
+#define STR_XGA			"XGA Graphics"

 #define STR_MOUSE		"Мышь:"
 #define STR_JOYSTICK		"Джойстик:"
--- a/src/win/languages/sl-SI.rc
+++ b/src/win/languages/sl-SI.rc
@@ -273,6 +273,7 @@ END
 #define STR_VIDEO		"Video:"
 #define STR_VOODOO		"Voodoo grafika"
 #define STR_IBM8514		"IBM 8514/a Graphics"
+#define STR_XGA			"XGA Graphics"

 #define STR_MOUSE		"Miška:"
 #define STR_JOYSTICK		"Igralna palica:"
--- a/src/win/languages/tr-TR.rc
+++ b/src/win/languages/tr-TR.rc
@@ -273,6 +273,7 @@ END
 #define STR_VIDEO		"Ekran kartı:"
 #define STR_VOODOO		"Voodoo Grafikleri"
 #define STR_IBM8514		"IBM 8514/a Graphics"
+#define STR_XGA			"XGA Graphics"

 #define STR_MOUSE		"Fare:"
 #define STR_JOYSTICK		"Oyun kolu:"
--- a/src/win/languages/uk-UA.rc
+++ b/src/win/languages/uk-UA.rc
@@ -273,6 +273,7 @@ END
 #define STR_VIDEO		"Відеокарта:"
 #define STR_VOODOO		"Прискорювач Voodoo"
 #define STR_IBM8514		"IBM 8514/a Graphics"
+#define STR_XGA			"XGA Graphics"

 #define STR_MOUSE		"Миша:"
 #define STR_JOYSTICK		"Джойстик:"
--- a/src/win/languages/zh-CN.rc
+++ b/src/win/languages/zh-CN.rc
@@ -273,6 +273,7 @@ END
 #define STR_VIDEO		"显卡:"
 #define STR_VOODOO		"Voodoo Graphics"
 #define STR_IBM8514		"IBM 8514/a Graphics"
+#define STR_XGA			"XGA Graphics"

 #define STR_MOUSE		"鼠标:"
 #define STR_JOYSTICK		"操纵杆:"
--- a/src/win/win.c
+++ b/src/win/win.c
@@ -549,8 +549,7 @@ main_thread(void *param)
 			frames = 0;
 		}
 	} else	/* Just so we dont overload the host OS. */
-		Sleep((drawits < -1) ? 1 : 0);
-		// Sleep(1);
+		Sleep(1);

 	/* If needed, handle a screen resize. */
 	if (!atomic_flag_test_and_set(&doresize) && !video_fullscreen && !is_quit) {
--- a/src/win/win_settings.c
+++ b/src/win/win_settings.c
@@ -16,6 +16,7 @@
 *		Copyright 2016-2019 Miran Grca.
 *		Copyright 2018,2019 David Hrdlička.
 *		Copyright 2021 Laci bá'
+ *		Copyright 2021-2022 Jasmine Iwanek.
 */
 #define UNICODE
 #define BITMAP WINDOWS_BITMAP
@@ -63,6 +64,7 @@
 #include <86box/midi.h>
 #include <86box/snd_mpu401.h>
 #include <86box/video.h>
+#include <86box/vid_xga_device.h>
 #include <86box/plat.h>
 #include <86box/ui.h>
 #include <86box/win.h>
@@ -85,7 +87,7 @@ static int temp_dynarec;
 #endif

 /* Video category */
-static int temp_gfxcard, temp_ibm8514, temp_voodoo;
+static int temp_gfxcard, temp_ibm8514, temp_voodoo, temp_xga;

 /* Input devices category */
 static int temp_mouse, temp_joystick;
@@ -333,6 +335,7 @@ win_settings_init(void)
    temp_gfxcard = gfxcard;
    temp_voodoo = voodoo_enabled;
    temp_ibm8514 = ibm8514_enabled;
+    temp_xga = xga_enabled;

    /* Input devices category */
    temp_mouse = mouse_type;
@@ -458,6 +461,7 @@ win_settings_changed(void)
    i = i || (gfxcard != temp_gfxcard);
    i = i || (voodoo_enabled != temp_voodoo);
    i = i || (ibm8514_enabled != temp_ibm8514);
+    i = i || (xga_enabled != temp_xga);

    /* Input devices category */
    i = i || (mouse_type != temp_mouse);
@@ -549,6 +553,7 @@ win_settings_save(void)
    gfxcard = temp_gfxcard;
    voodoo_enabled = temp_voodoo;
    ibm8514_enabled = temp_ibm8514;
+    xga_enabled = temp_xga;

    /* Input devices category */
    mouse_type = temp_mouse;
@@ -1116,6 +1121,11 @@ win_settings_video_proc(HWND hdlg, UINT message, WPARAM wParam, LPARAM lParam)

 		settings_enable_window(hdlg, IDC_CHECK_IBM8514, machine_has_bus(temp_machine, MACHINE_BUS_ISA16) || machine_has_bus(temp_machine, MACHINE_BUS_MCA));
 		settings_set_check(hdlg, IDC_CHECK_IBM8514, temp_ibm8514);
+
+		settings_enable_window(hdlg, IDC_CHECK_XGA, machine_has_bus(temp_machine, MACHINE_BUS_ISA16) || machine_has_bus(temp_machine, MACHINE_BUS_MCA));
+		settings_set_check(hdlg, IDC_CHECK_XGA, temp_xga);
+		settings_enable_window(hdlg, IDC_BUTTON_XGA, (machine_has_bus(temp_machine, MACHINE_BUS_ISA16) || machine_has_bus(temp_machine, MACHINE_BUS_MCA)) && temp_xga);
+
 		return TRUE;

 	case WM_COMMAND:
@@ -1134,10 +1144,23 @@ win_settings_video_proc(HWND hdlg, UINT message, WPARAM wParam, LPARAM lParam)
 				temp_ibm8514 = settings_get_check(hdlg, IDC_CHECK_IBM8514);
 				break;

+			case IDC_CHECK_XGA:
+				temp_xga = settings_get_check(hdlg, IDC_CHECK_XGA);
+				settings_enable_window(hdlg, IDC_BUTTON_XGA, temp_xga);
+				break;
+
 			case IDC_BUTTON_VOODOO:
 				temp_deviceconfig |= deviceconfig_open(hdlg, (void *)&voodoo_device);
 				break;

+			case IDC_BUTTON_XGA:
+				if (machine_has_bus(temp_machine, MACHINE_BUS_MCA) > 0) {
+					temp_deviceconfig |= deviceconfig_open(hdlg, (void *)&xga_device);
+				} else {
+					temp_deviceconfig |= deviceconfig_open(hdlg, (void *)&xga_isa_device);
+				}
+				break;
+
 			case IDC_CONFIGURE_VID:
 				temp_gfxcard = settings_list_to_device[0][settings_get_cur_sel(hdlg, IDC_COMBO_VIDEO)];
 				temp_deviceconfig |= deviceconfig_open(hdlg, (void *)video_card_getdevice(temp_gfxcard));
@@ -1149,6 +1172,7 @@ win_settings_video_proc(HWND hdlg, UINT message, WPARAM wParam, LPARAM lParam)
 		temp_gfxcard = settings_list_to_device[0][settings_get_cur_sel(hdlg, IDC_COMBO_VIDEO)];
 		temp_voodoo = settings_get_check(hdlg, IDC_CHECK_VOODOO);
 		temp_ibm8514 = settings_get_check(hdlg, IDC_CHECK_IBM8514);
+		temp_xga = settings_get_check(hdlg, IDC_CHECK_XGA);

 	default:
 		return FALSE;
--- a/Show More
+++ b/Show More