Merge branch 'master' into TemporaryHackishBranch

.travis.sh

@@ -79,6 +79,9 @@ travis_install() {
 
     if [ "$PPSSPP_BUILD_TYPE" = "macOS" ]; then
         brew_install sdl2
+        brew upgrade python
+    elif [ "$PPSSPP_BUILD_TYPE" = "iOS" ]; then
+        brew upgrade python
     fi
 
     # Ensure we're using ccache

.travis.yml

@@ -21,8 +21,10 @@ addons:
       - lib32bz2-1.0
 
 cache:
-  - apt
-  - ccache
+  apt: true
+  ccache: true
+  directories:
+    - $HOME/Library/Caches/Homebrew
 
 # By encrypting the channel name, we disable notifications from forks by default.
 # It's not actually a big secret.
@@ -74,14 +76,12 @@ matrix:
            LIBRETRO=TRUE
     - os: osx
       osx_image: xcode8
-      compiler: "clang macos"
+      compiler: "clang"
       env: PPSSPP_BUILD_TYPE=macOS
-           CMAKE=TRUE
     - os: osx
       osx_image: xcode8
-      compiler: "clang ios"
+      compiler: "clang"
       env: PPSSPP_BUILD_TYPE=iOS
-           CMAKE=TRUE
 
 before_install:
   - bash .travis.sh travis_before_install

Common/Vulkan/VulkanContext.cpp

@@ -895,6 +895,20 @@ int clamp(int x, int a, int b) {
 	return x;
 }
 
+static std::string surface_transforms_to_string(VkSurfaceTransformFlagsKHR transformFlags) {
+	std::string str;
+	if (transformFlags & VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR) str += "IDENTITY ";
+	if (transformFlags & VK_SURFACE_TRANSFORM_ROTATE_90_BIT_KHR) str += "ROTATE_90 ";
+	if (transformFlags & VK_SURFACE_TRANSFORM_ROTATE_180_BIT_KHR) str += "ROTATE_180 ";
+	if (transformFlags & VK_SURFACE_TRANSFORM_ROTATE_270_BIT_KHR) str += "ROTATE_270 ";
+	if (transformFlags & VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_BIT_KHR) str += "HMIRROR ";
+	if (transformFlags & VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_90_BIT_KHR) str += "HMIRROR_90 ";
+	if (transformFlags & VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_180_BIT_KHR) str += "HMIRROR_180 ";
+	if (transformFlags & VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_270_BIT_KHR) str += "HMIRROR_270 ";
+	if (transformFlags & VK_SURFACE_TRANSFORM_INHERIT_BIT_KHR) str += "INHERIT ";
+	return str;
+}
+
 bool VulkanContext::InitSwapchain() {
 	VkResult res = vkGetPhysicalDeviceSurfaceCapabilitiesKHR(physical_devices_[physical_device_], surface_, &surfCapabilities_);
 	assert(res == VK_SUCCESS);
@@ -915,6 +929,7 @@ bool VulkanContext::InitSwapchain() {
 
 	if (physicalDeviceProperties_[physical_device_].properties.vendorID == VULKAN_VENDOR_IMGTEC) {
 		// Swap chain width hack to avoid issue #11743 (PowerVR driver bug).
+		// TODO: Check if still broken if pretransform is used!
 		swapChainExtent_.width &= ~31;
 	}
 
@@ -961,19 +976,52 @@ bool VulkanContext::InitSwapchain() {
 		// Application must settle for fewer images than desired:
 		desiredNumberOfSwapChainImages = surfCapabilities_.maxImageCount;
 	}
-
+	
+	// We mostly follow the practices from
+	// https://arm-software.github.io/vulkan_best_practice_for_mobile_developers/samples/surface_rotation/surface_rotation_tutorial.html
+	// 
 	VkSurfaceTransformFlagBitsKHR preTransform;
-	if (surfCapabilities_.supportedTransforms & VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR) {
+	std::string supportedTransforms = surface_transforms_to_string(surfCapabilities_.supportedTransforms);
+	std::string currentTransform = surface_transforms_to_string(surfCapabilities_.currentTransform);
+	ILOG("Supported transforms: %s", supportedTransforms.c_str());
+	ILOG("Current transform: %s", currentTransform.c_str());
+	g_display_rotation = DisplayRotation::ROTATE_0;
+	g_display_rot_matrix.setIdentity();
+	bool swapChainExtentSwap = false;
+	if (surfCapabilities_.currentTransform & (VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR | VK_SURFACE_TRANSFORM_INHERIT_BIT_KHR)) {
 		preTransform = VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR;
-	} else {
+	} else if (surfCapabilities_.currentTransform & (VK_SURFACE_TRANSFORM_ROTATE_90_BIT_KHR | VK_SURFACE_TRANSFORM_ROTATE_180_BIT_KHR | VK_SURFACE_TRANSFORM_ROTATE_270_BIT_KHR)) {
+		// Normal, sensible rotations. Let's handle it.
 		preTransform = surfCapabilities_.currentTransform;
+		g_display_rot_matrix.setIdentity();
+		switch (surfCapabilities_.currentTransform) {
+		case VK_SURFACE_TRANSFORM_ROTATE_90_BIT_KHR:
+			g_display_rotation = DisplayRotation::ROTATE_90;
+			g_display_rot_matrix.setRotationZ90();
+			std::swap(swapChainExtent_.width, swapChainExtent_.height);
+			break;
+		case VK_SURFACE_TRANSFORM_ROTATE_180_BIT_KHR:
+			g_display_rotation = DisplayRotation::ROTATE_180;
+			g_display_rot_matrix.setRotationZ180();
+			break;
+		case VK_SURFACE_TRANSFORM_ROTATE_270_BIT_KHR:
+			g_display_rotation = DisplayRotation::ROTATE_270;
+			g_display_rot_matrix.setRotationZ270();
+			std::swap(swapChainExtent_.width, swapChainExtent_.height);
+			break;
+		}
+	} else {
+		// Let the OS rotate the image (potentially slow on many Android devices)
+		preTransform = VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR;
 	}
+	std::string preTransformStr = surface_transforms_to_string(preTransform);
+	ILOG("Chosen pretransform transform: %s", preTransformStr.c_str());
 
 	VkSwapchainCreateInfoKHR swap_chain_info{ VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR };
 	swap_chain_info.surface = surface_;
 	swap_chain_info.minImageCount = desiredNumberOfSwapChainImages;
 	swap_chain_info.imageFormat = swapchainFormat_;
-	swap_chain_info.imageColorSpace = VK_COLORSPACE_SRGB_NONLINEAR_KHR;
+	swap_chain_info.imageColorSpace = VK_COLOR_SPACE_SRGB_NONLINEAR_KHR;
 	swap_chain_info.imageExtent.width = swapChainExtent_.width;
 	swap_chain_info.imageExtent.height = swapChainExtent_.height;
 	swap_chain_info.preTransform = preTransform;
@@ -982,8 +1030,9 @@ bool VulkanContext::InitSwapchain() {
 	swap_chain_info.oldSwapchain = VK_NULL_HANDLE;
 	swap_chain_info.clipped = true;
 	swap_chain_info.imageUsage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
-	if (surfCapabilities_.supportedUsageFlags & VK_IMAGE_USAGE_TRANSFER_DST_BIT)
-		swap_chain_info.imageUsage |= VK_IMAGE_USAGE_TRANSFER_DST_BIT;
+	// Don't ask for TRANSFER_DST for the swapchain image, we don't use that.
+	// if (surfCapabilities_.supportedUsageFlags & VK_IMAGE_USAGE_TRANSFER_DST_BIT)
+	//	swap_chain_info.imageUsage |= VK_IMAGE_USAGE_TRANSFER_DST_BIT;
 
 #ifndef ANDROID
 	// We don't support screenshots on Android
@@ -1008,7 +1057,7 @@ bool VulkanContext::InitSwapchain() {
 		ELOG("vkCreateSwapchainKHR failed!");
 		return false;
 	}
-
+	ILOG("Created swapchain: %dx%d", swap_chain_info.imageExtent.width, swap_chain_info.imageExtent.height);
 	return true;
 }
 

Core/Config.cpp

@@ -120,6 +120,13 @@ struct ConfigSetting {
 		default_.i = def;
 	}
 
+	ConfigSetting(const char *ini, int *v, int def, std::function<std::string(int)> transTo, std::function<int(const std::string &)> transFrom, bool save = true, bool perGame = false)
+		: ini_(ini), type_(TYPE_INT), report_(false), save_(save), perGame_(perGame), translateTo_(transTo), translateFrom_(transFrom) {
+		ptr_.i = v;
+		cb_.i = nullptr;
+		default_.i = def;
+	}
+
 	ConfigSetting(const char *ini, uint32_t *v, uint32_t def, bool save = true, bool perGame = false)
 		: ini_(ini), type_(TYPE_UINT32), report_(false), save_(save), perGame_(perGame) {
 		ptr_.u = v;
@@ -160,6 +167,12 @@ struct ConfigSetting {
 		cb_.i = def;
 	}
 
+	ConfigSetting(const char *ini, int *v, IntDefaultCallback def, std::function<std::string(int)> transTo, std::function<int(const std::string &)> transFrom, bool save = true, bool perGame = false)
+		: ini_(ini), type_(TYPE_INT), report_(false), save_(save), perGame_(perGame), translateTo_(transTo), translateFrom_(transFrom) {
+		ptr_.i = v;
+		cb_.i = def;
+	}
+
 	ConfigSetting(const char *ini, uint32_t *v, Uint32DefaultCallback def, bool save = true, bool perGame = false)
 		: ini_(ini), type_(TYPE_UINT32), report_(false), save_(save), perGame_(perGame) {
 		ptr_ .u = v;
@@ -199,6 +212,13 @@ struct ConfigSetting {
 			if (cb_.i) {
 				default_.i = cb_.i();
 			}
+			if (translateFrom_) {
+				std::string value;
+				if (section->Get(ini_, &value, nullptr)) {
+					*ptr_.i = translateFrom_(value);
+					return true;
+				}
+			}
 			return section->Get(ini_, ptr_.i, default_.i);
 		case TYPE_UINT32:
 			if (cb_.u) {
@@ -242,6 +262,10 @@ struct ConfigSetting {
 		case TYPE_BOOL:
 			return section->Set(ini_, *ptr_.b);
 		case TYPE_INT:
+			if (translateTo_) {
+				std::string value = translateTo_(*ptr_.i);
+				return section->Set(ini_, value);
+			}
 			return section->Set(ini_, *ptr_.i);
 		case TYPE_UINT32:
 			return section->Set(ini_, *ptr_.u);
@@ -298,6 +322,10 @@ struct ConfigSetting {
 	SettingPtr ptr_;
 	Value default_;
 	Callback cb_;
+
+	// We only support transform for ints.
+	std::function<std::string(int)> translateTo_;
+	std::function<int(const std::string &)> translateFrom_;
 };
 
 struct ReportedConfigSetting : public ConfigSetting {
@@ -306,6 +334,12 @@ struct ReportedConfigSetting : public ConfigSetting {
 		: ConfigSetting(ini, v, def, save, perGame) {
 		report_ = true;
 	}
+
+	template <typename T1, typename T2>
+	ReportedConfigSetting(const char *ini, T1 *v, T2 def, std::function<std::string(int)> transTo, std::function<int(const std::string &)> transFrom, bool save = true, bool perGame = false)
+		: ConfigSetting(ini, v, def, transTo, transFrom, save, perGame) {
+		report_ = true;
+	}
 };
 
 const char *DefaultLangRegion() {
@@ -554,34 +588,43 @@ static int DefaultGPUBackend() {
 
 int Config::NextValidBackend() {
 	std::vector<std::string> split;
-	std::set<int> failed;
+	std::set<GPUBackend> failed;
+
 	SplitString(sFailedGPUBackends, ',', split);
 	for (const auto &str : split) {
 		if (!str.empty() && str != "ALL") {
-			failed.insert(atoi(str.c_str()));
+			failed.insert(GPUBackendFromString(str));
 		}
 	}
 
-	if (failed.count(iGPUBackend)) {
+	// Count these as "failed" too so we don't pick them.
+	SplitString(sDisabledGPUBackends, ',', split);
+	for (const auto &str : split) {
+		if (!str.empty()) {
+			failed.insert(GPUBackendFromString(str));
+		}
+	}
+
+	if (failed.count((GPUBackend)iGPUBackend)) {
 		ERROR_LOG(LOADER, "Graphics backend failed for %d, trying another", iGPUBackend);
 
 #if (PPSSPP_PLATFORM(WINDOWS) || PPSSPP_PLATFORM(ANDROID)) && !PPSSPP_PLATFORM(UWP)
-		if (VulkanMayBeAvailable() && !failed.count((int)GPUBackend::VULKAN)) {
+		if (!failed.count(GPUBackend::VULKAN) && VulkanMayBeAvailable()) {
 			return (int)GPUBackend::VULKAN;
 		}
 #endif
 #if PPSSPP_PLATFORM(WINDOWS)
-		if (DoesVersionMatchWindows(6, 1, 0, 0, true) && !failed.count((int)GPUBackend::DIRECT3D11)) {
+		if (!failed.count(GPUBackend::DIRECT3D11) && DoesVersionMatchWindows(6, 1, 0, 0, true)) {
 			return (int)GPUBackend::DIRECT3D11;
 		}
 #endif
 #if PPSSPP_API(ANY_GL)
-		if (!failed.count((int)GPUBackend::OPENGL)) {
+		if (!failed.count(GPUBackend::OPENGL)) {
 			return (int)GPUBackend::OPENGL;
 		}
 #endif
 #if PPSSPP_API(D3D9)
-		if (!failed.count((int)GPUBackend::DIRECT3D9)) {
+		if (!failed.count(GPUBackend::DIRECT3D9)) {
 			return (int)GPUBackend::DIRECT3D9;
 		}
 #endif
@@ -595,18 +638,78 @@ int Config::NextValidBackend() {
 	return iGPUBackend;
 }
 
+bool Config::IsBackendEnabled(GPUBackend backend, bool validate) {
+	std::vector<std::string> split;
+
+	SplitString(sDisabledGPUBackends, ',', split);
+	for (const auto &str : split) {
+		if (str.empty())
+			continue;
+		auto match = GPUBackendFromString(str);
+		if (match == backend)
+			return false;
+	}
+
+#if PPSSPP_PLATFORM(IOS)
+	if (backend != GPUBackend::OPENGL)
+		return false;
+#elif PPSSPP_PLATFORM(UWP)
+	if (backend != GPUBackend::DIRECT3D11)
+		return false;
+#elif PPSSPP_PLATFORM(WINDOWS)
+	if (validate) {
+		if (backend == GPUBackend::DIRECT3D11 && !DoesVersionMatchWindows(6, 0, 0, 0, true))
+			return false;
+	}
+#else
+	if (backend == GPUBackend::DIRECT3D11 || backend == GPUBackend::DIRECT3D9)
+		return false;
+#endif
+
+#if !PPSSPP_API(ANY_GL)
+	if (backend == GPUBackend::OPENGL)
+		return false;
+#endif
+#if !PPSSPP_PLATFORM(IOS)
+	if (validate) {
+		if (backend == GPUBackend::VULKAN && !VulkanMayBeAvailable())
+			return false;
+	}
+#endif
+
+	return true;
+}
+
 static bool DefaultVertexCache() {
 	return DefaultGPUBackend() == (int)GPUBackend::OPENGL;
 }
 
+template <typename T, std::string (*FTo)(T), T (*FFrom)(const std::string &)>
+struct ConfigTranslator {
+	static std::string To(int v) {
+		return StringFromInt(v) + " (" + FTo(T(v)) + ")";
+	}
+
+	static int From(const std::string &v) {
+		int result;
+		if (TryParse(v, &result)) {
+			return result;
+		}
+		return (int)FFrom(v);
+	}
+};
+
+typedef ConfigTranslator<GPUBackend, GPUBackendToString, GPUBackendFromString> GPUBackendTranslator;
+
 static ConfigSetting graphicsSettings[] = {
 	ConfigSetting("EnableCardboard", &g_Config.bEnableCardboard, false, true, true),
 	ConfigSetting("CardboardScreenSize", &g_Config.iCardboardScreenSize, 50, true, true),
 	ConfigSetting("CardboardXShift", &g_Config.iCardboardXShift, 0, true, true),
 	ConfigSetting("CardboardYShift", &g_Config.iCardboardXShift, 0, true, true),
 	ConfigSetting("ShowFPSCounter", &g_Config.iShowFPSCounter, 0, true, true),
-	ReportedConfigSetting("GraphicsBackend", &g_Config.iGPUBackend, &DefaultGPUBackend),
+	ReportedConfigSetting("GraphicsBackend", &g_Config.iGPUBackend, &DefaultGPUBackend, &GPUBackendTranslator::To, &GPUBackendTranslator::From, true, false),
 	ConfigSetting("FailedGraphicsBackends", &g_Config.sFailedGPUBackends, ""),
+	ConfigSetting("DisabledGraphicsBackends", &g_Config.sDisabledGPUBackends, ""),
 	ConfigSetting("VulkanDevice", &g_Config.sVulkanDevice, "", true, false),
 #ifdef _WIN32
 	ConfigSetting("D3D11Device", &g_Config.sD3D11Device, "", true, false),

Core/Config.h

@@ -23,6 +23,7 @@
 
 #include "ppsspp_config.h"
 #include "Common/CommonTypes.h"
+#include "Core/ConfigValues.h"
 
 extern const char *PPSSPP_GIT_VERSION;
 const int MAX_CONFIG_VOLUME = 8;
@@ -131,6 +132,7 @@ public:
 	// GFX
 	int iGPUBackend;
 	std::string sFailedGPUBackends;
+	std::string sDisabledGPUBackends;
 	// We have separate device parameters for each backend so it doesn't get erased if you switch backends.
 	// If not set, will use the "best" device.
 	std::string sVulkanDevice;
@@ -457,6 +459,7 @@ public:
 
 	bool IsPortrait() const;
 	int NextValidBackend();
+	bool IsBackendEnabled(GPUBackend backend, bool validate = true);
 
 protected:
 	void LoadStandardControllerIni();

Core/ConfigValues.h

@@ -18,6 +18,11 @@
 #pragma once
 
 #include <cstdint>
+#include <string>
+#ifndef _MSC_VER
+#include <strings.h>
+#endif
+#include "Common/CommonFuncs.h"
 
 const int PSP_MODEL_FAT = 0;
 const int PSP_MODEL_SLIM = 1;
@@ -53,6 +58,33 @@ enum class GPUBackend {
 	VULKAN = 3,
 };
 
+inline std::string GPUBackendToString(GPUBackend backend) {
+	switch (backend) {
+	case GPUBackend::OPENGL:
+		return "OPENGL";
+	case GPUBackend::DIRECT3D9:
+		return "DIRECT3D9";
+	case GPUBackend::DIRECT3D11:
+		return "DIRECT3D11";
+	case GPUBackend::VULKAN:
+		return "VULKAN";
+	}
+	// Intentionally not a default so we get a warning.
+	return "INVALID";
+}
+
+inline GPUBackend GPUBackendFromString(const std::string &backend) {
+	if (!strcasecmp(backend.c_str(), "OPENGL") || backend == "0")
+		return GPUBackend::OPENGL;
+	if (!strcasecmp(backend.c_str(), "DIRECT3D9") || backend == "1")
+		return GPUBackend::DIRECT3D9;
+	if (!strcasecmp(backend.c_str(), "DIRECT3D11") || backend == "2")
+		return GPUBackend::DIRECT3D11;
+	if (!strcasecmp(backend.c_str(), "VULKAN") || backend == "3")
+		return GPUBackend::VULKAN;
+	return GPUBackend::OPENGL;
+}
+
 enum AudioBackendType {
 	AUDIO_BACKEND_AUTO,
 	AUDIO_BACKEND_DSOUND,

Core/MIPS/MIPSIntVFPU.cpp

@@ -875,6 +875,10 @@ namespace MIPSInt
 			d[0] = ShrinkToHalf(s[0]) | ((u32)ShrinkToHalf(s[1]) << 16);
 			d[1] = ShrinkToHalf(s[2]) | ((u32)ShrinkToHalf(s[3]) << 16);
 			break;
+
+		default:
+			ERROR_LOG_REPORT(CPU, "vf2h with invalid elements");
+			break;
 		}
 		ApplyPrefixD(reinterpret_cast<float *>(d), outsize);
 		WriteVector(reinterpret_cast<float *>(d), outsize, vd);
@@ -940,7 +944,7 @@ namespace MIPSInt
 				break;
 
 			default:
-				ERROR_LOG_REPORT(CPU, "vus2i with more than 2 elements.");
+				ERROR_LOG_REPORT(CPU, "vus2i with more than 2 elements");
 				break;
 			}
 			break;
@@ -964,7 +968,7 @@ namespace MIPSInt
 				break;
 
 			default:
-				ERROR_LOG_REPORT(CPU, "vs2i with more than 2 elements.");
+				ERROR_LOG_REPORT(CPU, "vs2i with more than 2 elements");
 				break;
 			}
 			break;
@@ -2099,6 +2103,10 @@ namespace MIPSInt
 			// t swizzles invalid so the multiply is always zero.
 			d[0] = 0;
 			break;
+
+		default:
+			ERROR_LOG_REPORT(CPU, "vcrsp/vqmul with invalid elements");
+			break;
 		}
 
 		// D prefix applies to the last element only (mask and sat) for pair and larger.

Core/MIPS/MIPSVFPUUtils.h

@@ -123,27 +123,27 @@ enum MatrixSize {
 	M_Invalid = -1
 };
 
-static u32 VFPU_SWIZZLE(int x, int y, int z, int w) {
+inline u32 VFPU_SWIZZLE(int x, int y, int z, int w) {
 	return (x << 0) | (y << 2) | (z << 4) | (w << 6);
 }
 
-static u32 VFPU_MASK(int x, int y, int z, int w) {
+inline u32 VFPU_MASK(int x, int y, int z, int w) {
 	return (x << 0) | (y << 1) | (z << 2) | (w << 3);
 }
 
-static u32 VFPU_ANY_SWIZZLE() {
+inline u32 VFPU_ANY_SWIZZLE() {
 	return 0x000000FF;
 }
 
-static u32 VFPU_ABS(int x, int y, int z, int w) {
+inline u32 VFPU_ABS(int x, int y, int z, int w) {
 	return VFPU_MASK(x, y, z, w) << 8;
 }
 
-static u32 VFPU_CONST(int x, int y, int z, int w) {
+inline u32 VFPU_CONST(int x, int y, int z, int w) {
 	return VFPU_MASK(x, y, z, w) << 12;
 }
 
-static u32 VFPU_NEGATE(int x, int y, int z, int w) {
+inline u32 VFPU_NEGATE(int x, int y, int z, int w) {
 	return VFPU_MASK(x, y, z, w) << 16;
 }
 
@@ -159,7 +159,7 @@ enum class VFPUConst {
 	SIXTH,
 };
 
-static u32 VFPU_MAKE_CONSTANTS(VFPUConst x, VFPUConst y, VFPUConst z, VFPUConst w) {
+inline u32 VFPU_MAKE_CONSTANTS(VFPUConst x, VFPUConst y, VFPUConst z, VFPUConst w) {
 	u32 result = 0;
 	if (x != VFPUConst::NONE) {
 		// This sets the constant flag and the swizzle/abs flags for the right constant.

Core/WebServer.cpp

@@ -146,24 +146,24 @@ static void RegisterDiscHandlers(http::Server *http, std::unordered_map<std::str
 
 		std::string range;
 		if (request.Method() == http::RequestHeader::HEAD) {
-			request.WriteHttpResponseHeader(200, sz, "application/octet-stream", "Accept-Ranges: bytes\r\n");
+			request.WriteHttpResponseHeader("1.0", 200, sz, "application/octet-stream", "Accept-Ranges: bytes\r\n");
 		} else if (request.GetHeader("range", &range)) {
 			s64 begin = 0, last = 0;
 			if (sscanf(range.c_str(), "bytes=%lld-%lld", &begin, &last) != 2) {
-				request.WriteHttpResponseHeader(400, -1, "text/plain");
+				request.WriteHttpResponseHeader("1.0", 400, -1, "text/plain");
 				request.Out()->Push("Could not understand range request.");
 				return;
 			}
 
 			if (begin < 0 || begin > last || last >= sz) {
-				request.WriteHttpResponseHeader(416, -1, "text/plain");
+				request.WriteHttpResponseHeader("1.0", 416, -1, "text/plain");
 				request.Out()->Push("Range goes outside of file.");
 				return;
 			}
 
 			FILE *fp = File::OpenCFile(filename, "rb");
 			if (!fp || fseek(fp, begin, SEEK_SET) != 0) {
-				request.WriteHttpResponseHeader(500, -1, "text/plain");
+				request.WriteHttpResponseHeader("1.0", 500, -1, "text/plain");
 				request.Out()->Push("File access failed.");
 				if (fp) {
 					fclose(fp);
@@ -174,7 +174,7 @@ static void RegisterDiscHandlers(http::Server *http, std::unordered_map<std::str
 			s64 len = last - begin + 1;
 			char contentRange[1024];
 			sprintf(contentRange, "Content-Range: bytes %lld-%lld/%lld\r\n", begin, last, sz);
-			request.WriteHttpResponseHeader(206, len, "application/octet-stream", contentRange);
+			request.WriteHttpResponseHeader("1.0", 206, len, "application/octet-stream", contentRange);
 
 			const size_t CHUNK_SIZE = 16 * 1024;
 			char *buf = new char[CHUNK_SIZE];
@@ -188,7 +188,7 @@ static void RegisterDiscHandlers(http::Server *http, std::unordered_map<std::str
 			delete [] buf;
 			request.Out()->Flush();
 		} else {
-			request.WriteHttpResponseHeader(418, -1, "text/plain");
+			request.WriteHttpResponseHeader("1.0", 418, -1, "text/plain");
 			request.Out()->Push("This server only supports range requests.");
 		}
 	};

GPU/Common/FramebufferCommon.cpp

@@ -727,6 +727,7 @@ void FramebufferManagerCommon::DrawPixels(VirtualFramebuffer *vfb, int dstX, int
 	float u0 = 0.0f, u1 = 1.0f;
 	float v0 = 0.0f, v1 = 1.0f;
 
+	DrawTextureFlags flags = (vfb || g_Config.iBufFilter == SCALE_LINEAR) ? DRAWTEX_LINEAR : DRAWTEX_NEAREST;
 	if (useBufferedRendering_ && vfb && vfb->fbo) {
 		draw_->BindFramebufferAsRenderTarget(vfb->fbo, { Draw::RPAction::KEEP, Draw::RPAction::KEEP, Draw::RPAction::KEEP });
 		SetViewport2D(0, 0, vfb->renderWidth, vfb->renderHeight);
@@ -735,6 +736,7 @@ void FramebufferManagerCommon::DrawPixels(VirtualFramebuffer *vfb, int dstX, int
 		// We are drawing to the back buffer so need to flip.
 		if (needBackBufferYSwap_)
 			std::swap(v0, v1);
+		flags = flags | DRAWTEX_TO_BACKBUFFER;
 		float x, y, w, h;
 		CenterDisplayOutputRect(&x, &y, &w, &h, 480.0f, 272.0f, (float)pixelWidth_, (float)pixelHeight_, ROTATION_LOCKED_HORIZONTAL);
 		SetViewport2D(x, y, w, h);
@@ -743,7 +745,6 @@ void FramebufferManagerCommon::DrawPixels(VirtualFramebuffer *vfb, int dstX, int
 
 	MakePixelTexture(srcPixels, srcPixelFormat, srcStride, width, height, u1, v1);
 
-	DrawTextureFlags flags = (vfb || g_Config.iBufFilter == SCALE_LINEAR) ? DRAWTEX_LINEAR : DRAWTEX_NEAREST;
 	Bind2DShader();
 	DrawActiveTexture(dstX, dstY, width, height, vfb->bufferWidth, vfb->bufferHeight, u0, v0, u1, v1, ROTATION_LOCKED_HORIZONTAL, flags);
 	gpuStats.numUploads++;
@@ -810,6 +811,7 @@ void FramebufferManagerCommon::DrawFramebufferToOutput(const u8 *srcPixels, GEBu
 		std::swap(v0, v1);
 
 	DrawTextureFlags flags = g_Config.iBufFilter == SCALE_LINEAR ? DRAWTEX_LINEAR : DRAWTEX_NEAREST;
+	flags = flags | DRAWTEX_TO_BACKBUFFER;
 	if (cardboardSettings.enabled) {
 		// Left Eye Image
 		SetViewport2D(cardboardSettings.leftEyeXPosition, cardboardSettings.screenYPosition, cardboardSettings.screenWidth, cardboardSettings.screenHeight);
@@ -977,10 +979,11 @@ void FramebufferManagerCommon::CopyDisplayToOutput() {
 			draw_->BindFramebufferAsRenderTarget(nullptr, { Draw::RPAction::CLEAR, Draw::RPAction::CLEAR, Draw::RPAction::CLEAR });
 			draw_->BindFramebufferAsTexture(vfb->fbo, 0, Draw::FB_COLOR_BIT, 0);
 			draw_->SetScissorRect(0, 0, pixelWidth_, pixelHeight_);
+			Bind2DShader();
 			DrawTextureFlags flags = g_Config.iBufFilter == SCALE_LINEAR ? DRAWTEX_LINEAR : DRAWTEX_NEAREST;
+			flags = flags | DRAWTEX_TO_BACKBUFFER;
 			// We are doing the DrawActiveTexture call directly to the backbuffer here. Hence, we must
 			// flip V.
-			Bind2DShader();
 			if (needBackBufferYSwap_)
 				std::swap(v0, v1);
 			if (cardboardSettings.enabled) {
@@ -1009,6 +1012,7 @@ void FramebufferManagerCommon::CopyDisplayToOutput() {
 			CalculatePostShaderUniforms(vfb->bufferWidth, vfb->bufferHeight, renderWidth_, renderHeight_, &uniforms);
 			BindPostShader(uniforms);
 			DrawTextureFlags flags = g_Config.iBufFilter == SCALE_LINEAR ? DRAWTEX_LINEAR : DRAWTEX_NEAREST;
+			flags = flags | DRAWTEX_TO_BACKBUFFER;
 			DrawActiveTexture(0, 0, fbo_w, fbo_h, fbo_w, fbo_h, 0.0f, 0.0f, 1.0f, 1.0f, ROTATION_LOCKED_HORIZONTAL, flags);
 
 			draw_->SetScissorRect(0, 0, pixelWidth_, pixelHeight_);
@@ -1028,6 +1032,7 @@ void FramebufferManagerCommon::CopyDisplayToOutput() {
 				std::swap(v0, v1);
 			Bind2DShader();
 			flags = (!postShaderIsUpscalingFilter_ && g_Config.iBufFilter == SCALE_LINEAR) ? DRAWTEX_LINEAR : DRAWTEX_NEAREST;
+			flags = flags | DRAWTEX_TO_BACKBUFFER;
 			if (g_Config.bEnableCardboard) {
 				// Left Eye Image
 				SetViewport2D(cardboardSettings.leftEyeXPosition, cardboardSettings.screenYPosition, cardboardSettings.screenWidth, cardboardSettings.screenHeight);
@@ -1051,6 +1056,7 @@ void FramebufferManagerCommon::CopyDisplayToOutput() {
 			if (needBackBufferYSwap_)
 				std::swap(v0, v1);
 			DrawTextureFlags flags = (!postShaderIsUpscalingFilter_ && g_Config.iBufFilter == SCALE_LINEAR) ? DRAWTEX_LINEAR : DRAWTEX_NEAREST;
+			flags = flags | DRAWTEX_TO_BACKBUFFER;
 
 			PostShaderUniforms uniforms{};
 			CalculatePostShaderUniforms(vfb->bufferWidth, vfb->bufferHeight, vfb->renderWidth, vfb->renderHeight, &uniforms);

GPU/Common/FramebufferCommon.h

@@ -155,8 +155,13 @@ enum DrawTextureFlags {
 	DRAWTEX_LINEAR = 1,
 	DRAWTEX_KEEP_TEX = 2,
 	DRAWTEX_KEEP_STENCIL_ALPHA = 4,
+	DRAWTEX_TO_BACKBUFFER = 8,
 };
 
+inline DrawTextureFlags operator | (const DrawTextureFlags &lhs, const DrawTextureFlags &rhs) {
+	return DrawTextureFlags((u32)lhs | (u32)rhs);
+}
+
 enum class TempFBO {
 	DEPAL,
 	BLIT,

GPU/Common/ShaderTranslation.cpp

@@ -24,6 +24,9 @@
 // DbgNew is not compatible with Glslang
 #ifdef DBG_NEW
 #undef new
+#undef free
+#undef malloc
+#undef realloc
 #endif
 
 #include "base/logging.h"

GPU/Debugger/Record.cpp

@@ -822,7 +822,7 @@ void NotifyDisplay(u32 framebuf, int stride, int fmt) {
 		int linesize, pixelFormat;
 	};
 
-	DisplayBufData disp{ framebuf, stride, fmt };
+	DisplayBufData disp{ { framebuf }, stride, fmt };
 
 	FlushRegisters();
 	u32 ptr = (u32)pushbuf.size();

GPU/GLES/DepalettizeShaderGLES.h

@@ -64,7 +64,6 @@ private:
 
 	GLRenderManager *render_;
 	bool useGL3_;
-	bool vertexShaderFailed_ = false;
 	GLRShader *vertexShader_ = nullptr;
 	std::map<u32, DepalShader *> cache_;
 	std::map<u32, DepalTexture *> texCache_;

GPU/Vulkan/FramebufferVulkan.cpp

@@ -20,6 +20,7 @@
 
 #include "profiler/profiler.h"
 
+#include "base/display.h"
 #include "base/timeutil.h"
 #include "math/lin/matrix4x4.h"
 #include "math/dataconv.h"
@@ -302,6 +303,16 @@ void FramebufferManagerVulkan::DrawActiveTexture(float x, float y, float w, floa
 		vtx[i].y = vtx[i].y * invDestH - 1.0f;
 	}
 
+	if ((flags & DRAWTEX_TO_BACKBUFFER) && g_display_rotation != DisplayRotation::ROTATE_0) {
+		for (int i = 0; i < 4; i++) {
+			// backwards notation, should fix that...
+			Vec3 v(vtx[i].x, vtx[i].y, 0.0f);
+			v = v * g_display_rot_matrix;
+			vtx[i].x = v.x;
+			vtx[i].y = v.y;
+		}
+	}
+
 	draw_->FlushState();
 
 	// TODO: Should probably use draw_ directly and not go low level

UI/DiscordIntegration.cpp

@@ -31,10 +31,12 @@ Discord g_Discord;
 
 static const char *ppsspp_app_id = "423397985041383434";
 
+#ifdef ENABLE_DISCORD
 // No context argument? What?
 static void handleDiscordError(int errCode, const char *message) {
 	ERROR_LOG(SYSTEM, "Discord error code %d: '%s'", errCode, message);
 }
+#endif
 
 Discord::~Discord() {
 	assert(!initialized_);

UI/GameSettingsScreen.cpp

@@ -68,8 +68,6 @@
 #include "Windows/W32Util/ShellUtil.h"
 #endif
 
-extern bool VulkanMayBeAvailable();
-
 GameSettingsScreen::GameSettingsScreen(std::string gamePath, std::string gameID, bool editThenRestore)
 	: UIDialogScreenWithGameBackground(gamePath), gameID_(gameID), enableReports_(false), editThenRestore_(editThenRestore) {
 	lastVertical_ = UseVerticalLayout();
@@ -204,26 +202,17 @@ void GameSettingsScreen::CreateViews() {
 	static const char *renderingBackend[] = { "OpenGL", "Direct3D 9", "Direct3D 11", "Vulkan" };
 	PopupMultiChoice *renderingBackendChoice = graphicsSettings->Add(new PopupMultiChoice(&g_Config.iGPUBackend, gr->T("Backend"), renderingBackend, (int)GPUBackend::OPENGL, ARRAY_SIZE(renderingBackend), gr->GetName(), screenManager()));
 	renderingBackendChoice->OnChoice.Handle(this, &GameSettingsScreen::OnRenderingBackend);
-#if !PPSSPP_PLATFORM(WINDOWS)
-	renderingBackendChoice->HideChoice(1);  // D3D9
-	renderingBackendChoice->HideChoice(2);  // D3D11
-#else
-#if !PPSSPP_API(ANY_GL)
-	renderingBackendChoice->HideChoice(0);  // OpenGL
-#endif
-	if (!DoesVersionMatchWindows(6, 0, 0, 0, true)) {
-		// Hide the D3D11 choice if Windows version is older than Windows Vista.
-		renderingBackendChoice->HideChoice(2);  // D3D11
-	}
-#endif
-	bool vulkanAvailable = false;
-#ifndef IOS
-	vulkanAvailable = VulkanMayBeAvailable();
-#endif
-	if (!vulkanAvailable) {
-		renderingBackendChoice->HideChoice(3);
-	}
+
+	if (!g_Config.IsBackendEnabled(GPUBackend::OPENGL))
+		renderingBackendChoice->HideChoice((int)GPUBackend::OPENGL);
+	if (!g_Config.IsBackendEnabled(GPUBackend::DIRECT3D9))
+		renderingBackendChoice->HideChoice((int)GPUBackend::DIRECT3D9);
+	if (!g_Config.IsBackendEnabled(GPUBackend::DIRECT3D11))
+		renderingBackendChoice->HideChoice((int)GPUBackend::DIRECT3D11);
+	if (!g_Config.IsBackendEnabled(GPUBackend::VULKAN))
+		renderingBackendChoice->HideChoice((int)GPUBackend::VULKAN);
 #endif
+
 	Draw::DrawContext *draw = screenManager()->getDrawContext();
 
 	// Backends that don't allow a device choice will only expose one device.

UI/NativeApp.cpp

@@ -392,9 +392,9 @@ static void CheckFailedGPUBackends() {
 		WARN_LOG(LOADER, "Failed graphics backend switched from %d to %d", lastBackend, g_Config.iGPUBackend);
 	// And then let's - for now - add the current to the failed list.
 	if (g_Config.sFailedGPUBackends.empty()) {
-		g_Config.sFailedGPUBackends = StringFromFormat("%d", g_Config.iGPUBackend);
+		g_Config.sFailedGPUBackends = GPUBackendToString((GPUBackend)g_Config.iGPUBackend);
 	} else if (g_Config.sFailedGPUBackends.find("ALL") == std::string::npos) {
-		g_Config.sFailedGPUBackends += StringFromFormat(",%d", g_Config.iGPUBackend);
+		g_Config.sFailedGPUBackends += "," + GPUBackendToString((GPUBackend)g_Config.iGPUBackend);
 	}
 
 	if (System_GetPropertyBool(SYSPROP_SUPPORTS_PERMISSIONS)) {

UWP/SPIRVCross_UWP/SPIRVCross_UWP.vcxproj

@@ -371,20 +371,26 @@
     <ClInclude Include="..\..\ext\SPIRV-Cross\spirv_cfg.hpp" />
     <ClInclude Include="..\..\ext\SPIRV-Cross\spirv_common.hpp" />
     <ClInclude Include="..\..\ext\SPIRV-Cross\spirv_cross.hpp" />
+    <ClInclude Include="..\..\ext\SPIRV-Cross\spirv_cross_containers.hpp" />
+    <ClInclude Include="..\..\ext\SPIRV-Cross\spirv_cross_error_handling.hpp" />
+    <ClInclude Include="..\..\ext\SPIRV-Cross\spirv_cross_parsed_ir.hpp" />
     <ClInclude Include="..\..\ext\SPIRV-Cross\spirv_cross_util.hpp" />
     <ClInclude Include="..\..\ext\SPIRV-Cross\spirv_glsl.hpp" />
     <ClInclude Include="..\..\ext\SPIRV-Cross\spirv_hlsl.hpp" />
     <ClInclude Include="..\..\ext\SPIRV-Cross\spirv_msl.hpp" />
+    <ClInclude Include="..\..\ext\SPIRV-Cross\spirv_parser.hpp" />
     <ClInclude Include="pch.h" />
     <ClInclude Include="targetver.h" />
   </ItemGroup>
   <ItemGroup>
     <ClCompile Include="..\..\ext\SPIRV-Cross\spirv_cfg.cpp" />
     <ClCompile Include="..\..\ext\SPIRV-Cross\spirv_cross.cpp" />
+    <ClCompile Include="..\..\ext\SPIRV-Cross\spirv_cross_parsed_ir.cpp" />
     <ClCompile Include="..\..\ext\SPIRV-Cross\spirv_cross_util.cpp" />
     <ClCompile Include="..\..\ext\SPIRV-Cross\spirv_glsl.cpp" />
     <ClCompile Include="..\..\ext\SPIRV-Cross\spirv_hlsl.cpp" />
     <ClCompile Include="..\..\ext\SPIRV-Cross\spirv_msl.cpp" />
+    <ClCompile Include="..\..\ext\SPIRV-Cross\spirv_parser.cpp" />
     <ClCompile Include="pch.cpp">
       <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">Create</PrecompiledHeader>
       <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">Create</PrecompiledHeader>
@@ -403,4 +409,4 @@
   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
   <ImportGroup Label="ExtensionTargets">
   </ImportGroup>
-</Project>
+</Project>

UWP/SPIRVCross_UWP/SPIRVCross_UWP.vcxproj.filters

@@ -14,6 +14,8 @@
     <ClCompile Include="..\..\ext\SPIRV-Cross\spirv_hlsl.cpp" />
     <ClCompile Include="..\..\ext\SPIRV-Cross\spirv_msl.cpp" />
     <ClCompile Include="..\..\ext\SPIRV-Cross\spirv_cross_util.cpp" />
+    <ClCompile Include="..\..\ext\SPIRV-Cross\spirv_cross_parsed_ir.cpp" />
+    <ClCompile Include="..\..\ext\SPIRV-Cross\spirv_parser.cpp" />
   </ItemGroup>
   <ItemGroup>
     <ClInclude Include="pch.h" />
@@ -26,5 +28,9 @@
     <ClInclude Include="..\..\ext\SPIRV-Cross\spirv_hlsl.hpp" />
     <ClInclude Include="..\..\ext\SPIRV-Cross\spirv_msl.hpp" />
     <ClInclude Include="..\..\ext\SPIRV-Cross\spirv_cross_util.hpp" />
+    <ClInclude Include="..\..\ext\SPIRV-Cross\spirv_cross_containers.hpp" />
+    <ClInclude Include="..\..\ext\SPIRV-Cross\spirv_cross_error_handling.hpp" />
+    <ClInclude Include="..\..\ext\SPIRV-Cross\spirv_cross_parsed_ir.hpp" />
+    <ClInclude Include="..\..\ext\SPIRV-Cross\spirv_parser.hpp" />
   </ItemGroup>
 </Project>

Windows/MainWindowMenu.cpp

@@ -1361,14 +1361,11 @@ namespace MainWindow {
 			CheckMenuItem(menu, savestateSlot[i], MF_BYCOMMAND | ((i == g_Config.iCurrentStateSlot) ? MF_CHECKED : MF_UNCHECKED));
 		}
 
-		bool allowD3D11 = DoesVersionMatchWindows(6, 0, 0, 0, true);
-		bool allowVulkan = VulkanMayBeAvailable();
+		bool allowD3D9 = g_Config.IsBackendEnabled(GPUBackend::DIRECT3D9);
+		bool allowD3D11 = g_Config.IsBackendEnabled(GPUBackend::DIRECT3D11);
+		bool allowOpenGL = g_Config.IsBackendEnabled(GPUBackend::OPENGL);
+		bool allowVulkan = g_Config.IsBackendEnabled(GPUBackend::VULKAN);
 
-#if PPSSPP_API(ANY_GL)
-		bool allowOpenGL = true;
-#else
-		bool allowOpenGL = false;
-#endif
 		switch (GetGPUBackend()) {
 		case GPUBackend::DIRECT3D9:
 			EnableMenuItem(menu, ID_OPTIONS_DIRECT3D9, MF_GRAYED);
@@ -1381,7 +1378,7 @@ namespace MainWindow {
 			CheckMenuItem(menu, ID_OPTIONS_VULKAN, MF_UNCHECKED);
 			break;
 		case GPUBackend::OPENGL:
-			EnableMenuItem(menu, ID_OPTIONS_DIRECT3D9, MF_ENABLED);
+			EnableMenuItem(menu, ID_OPTIONS_DIRECT3D9, allowD3D9 ? MF_ENABLED : MF_GRAYED);
 			EnableMenuItem(menu, ID_OPTIONS_DIRECT3D11, allowD3D11 ? MF_ENABLED : MF_GRAYED);
 			EnableMenuItem(menu, ID_OPTIONS_OPENGL, MF_GRAYED);
 			EnableMenuItem(menu, ID_OPTIONS_VULKAN, allowVulkan ? MF_ENABLED : MF_GRAYED);
@@ -1391,7 +1388,7 @@ namespace MainWindow {
 			CheckMenuItem(menu, ID_OPTIONS_VULKAN, MF_UNCHECKED);
 			break;
 		case GPUBackend::VULKAN:
-			EnableMenuItem(menu, ID_OPTIONS_DIRECT3D9, MF_ENABLED);
+			EnableMenuItem(menu, ID_OPTIONS_DIRECT3D9, allowD3D9 ? MF_ENABLED : MF_GRAYED);
 			EnableMenuItem(menu, ID_OPTIONS_DIRECT3D11, allowD3D11 ? MF_ENABLED : MF_GRAYED);
 			EnableMenuItem(menu, ID_OPTIONS_OPENGL, allowOpenGL ? MF_ENABLED : MF_GRAYED);
 			EnableMenuItem(menu, ID_OPTIONS_VULKAN, MF_GRAYED);
@@ -1401,7 +1398,7 @@ namespace MainWindow {
 			CheckMenuItem(menu, ID_OPTIONS_VULKAN, MF_CHECKED);
 			break;
 		case GPUBackend::DIRECT3D11:
-			EnableMenuItem(menu, ID_OPTIONS_DIRECT3D9, MF_ENABLED);
+			EnableMenuItem(menu, ID_OPTIONS_DIRECT3D9, allowD3D9 ? MF_ENABLED : MF_GRAYED);
 			EnableMenuItem(menu, ID_OPTIONS_DIRECT3D11, MF_GRAYED);
 			EnableMenuItem(menu, ID_OPTIONS_OPENGL, allowOpenGL ? MF_ENABLED : MF_GRAYED);
 			EnableMenuItem(menu, ID_OPTIONS_VULKAN, allowVulkan ? MF_ENABLED : MF_GRAYED);

Windows/main.cpp

@@ -572,7 +572,9 @@ int WINAPI WinMain(HINSTANCE _hInstance, HINSTANCE hPrevInstance, LPSTR szCmdLin
 
 #ifndef _DEBUG
 	// See #11719 - too many Vulkan drivers crash on basic init.
-	VulkanSetAvailable(DetectVulkanInExternalProcess());
+	if (g_Config.IsBackendEnabled(GPUBackend::VULKAN)) {
+		VulkanSetAvailable(DetectVulkanInExternalProcess());
+	}
 #endif
 
 	if (iCmdShow == SW_MAXIMIZE) {

android/jni/Android.mk

@@ -150,7 +150,9 @@ SPIRV_CROSS_FILES := \
   $(SRC)/ext/SPIRV-Cross/spirv_cfg.cpp \
   $(SRC)/ext/SPIRV-Cross/spirv_cross.cpp \
   $(SRC)/ext/SPIRV-Cross/spirv_cross_util.cpp \
-  $(SRC)/ext/SPIRV-Cross/spirv_glsl.cpp
+  $(SRC)/ext/SPIRV-Cross/spirv_glsl.cpp \
+  $(SRC)/ext/SPIRV-Cross/spirv_parser.cpp \
+  $(SRC)/ext/SPIRV-Cross/spirv_cross_parsed_ir.cpp
 
 EXEC_AND_LIB_FILES := \
   $(ARCH_FILES) \

ext/SPIRV-Cross-build/CMakeLists.txt

@@ -26,9 +26,16 @@ add_library(spirv-cross-core STATIC
 		${SRCDIR}/spirv.hpp
 		${SRCDIR}/spirv_cross.hpp
 		${SRCDIR}/spirv_cross.cpp
+		${SRCDIR}/spirv_cross_containers.hpp
+		${SRCDIR}/spirv_cross_error_handling.hpp
+		${SRCDIR}/spirv_cross_util.hpp
 		${SRCDIR}/spirv_cross_util.cpp
 		${SRCDIR}/spirv_cfg.hpp
-		${SRCDIR}/spirv_cfg.cpp)
+		${SRCDIR}/spirv_cfg.cpp
+		${SRCDIR}/spirv_cross_parsed_ir.hpp
+		${SRCDIR}/spirv_cross_parsed_ir.cpp
+		${SRCDIR}/spirv_parser.hpp
+		${SRCDIR}/spirv_parser.cpp)
 
 add_library(spirv-cross-glsl STATIC
 		${SRCDIR}/spirv_glsl.cpp

ext/SPIRV-Cross.vcxproj

@@ -312,19 +312,25 @@
     <ClInclude Include="SPIRV-Cross\spirv_common.hpp" />
     <ClInclude Include="SPIRV-Cross\spirv_cpp.hpp" />
     <ClInclude Include="SPIRV-Cross\spirv_cross.hpp" />
+    <ClInclude Include="SPIRV-Cross\spirv_cross_containers.hpp" />
+    <ClInclude Include="SPIRV-Cross\spirv_cross_error_handling.hpp" />
+    <ClInclude Include="SPIRV-Cross\spirv_cross_parsed_ir.hpp" />
     <ClInclude Include="SPIRV-Cross\spirv_cross_util.hpp" />
     <ClInclude Include="SPIRV-Cross\spirv_glsl.hpp" />
     <ClInclude Include="SPIRV-Cross\spirv_hlsl.hpp" />
     <ClInclude Include="SPIRV-Cross\spirv_msl.hpp" />
+    <ClInclude Include="SPIRV-Cross\spirv_parser.hpp" />
   </ItemGroup>
   <ItemGroup>
     <ClCompile Include="SPIRV-Cross\spirv_cfg.cpp" />
     <ClCompile Include="SPIRV-Cross\spirv_cpp.cpp" />
     <ClCompile Include="SPIRV-Cross\spirv_cross.cpp" />
+    <ClCompile Include="SPIRV-Cross\spirv_cross_parsed_ir.cpp" />
     <ClCompile Include="SPIRV-Cross\spirv_cross_util.cpp" />
     <ClCompile Include="SPIRV-Cross\spirv_glsl.cpp" />
     <ClCompile Include="SPIRV-Cross\spirv_hlsl.cpp" />
     <ClCompile Include="SPIRV-Cross\spirv_msl.cpp" />
+    <ClCompile Include="SPIRV-Cross\spirv_parser.cpp" />
   </ItemGroup>
   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
   <ImportGroup Label="ExtensionTargets">

ext/SPIRV-Cross.vcxproj.filters

@@ -10,6 +10,10 @@
     <ClInclude Include="SPIRV-Cross\spirv_hlsl.hpp" />
     <ClInclude Include="SPIRV-Cross\spirv_msl.hpp" />
     <ClInclude Include="SPIRV-Cross\spirv_cross_util.hpp" />
+    <ClInclude Include="SPIRV-Cross\spirv_cross_containers.hpp" />
+    <ClInclude Include="SPIRV-Cross\spirv_cross_error_handling.hpp" />
+    <ClInclude Include="SPIRV-Cross\spirv_cross_parsed_ir.hpp" />
+    <ClInclude Include="SPIRV-Cross\spirv_parser.hpp" />
   </ItemGroup>
   <ItemGroup>
     <ClCompile Include="SPIRV-Cross\spirv_cfg.cpp" />
@@ -19,5 +23,7 @@
     <ClCompile Include="SPIRV-Cross\spirv_hlsl.cpp" />
     <ClCompile Include="SPIRV-Cross\spirv_msl.cpp" />
     <ClCompile Include="SPIRV-Cross\spirv_cross_util.cpp" />
+    <ClCompile Include="SPIRV-Cross\spirv_cross_parsed_ir.cpp" />
+    <ClCompile Include="SPIRV-Cross\spirv_parser.cpp" />
   </ItemGroup>
 </Project>

ext/native/math/lin/matrix4x4.cpp

@@ -234,36 +234,6 @@ void Matrix4x4::setOrthoVulkan(float left, float right, float top, float bottom,
 	ww = 1.0f;
 }
 
-void Matrix4x4::setProjectionInf(const float near_plane, const float fov_horiz, const float aspect) {
-	empty();
-	float f = fov_horiz*0.5f;
-	xx = 1.0f / tanf(f);
-	yy = 1.0f / tanf(f*aspect);
-	zz = 1;
-	wz = -near_plane;
-	zw = 1.0f;
-}
-
-void Matrix4x4::setRotationAxisAngle(const Vec3 &axis, float angle) {
-	Quaternion quat;
-	quat.setRotation(axis, angle);
-	quat.toMatrix(this);
-}
-
-// from a (Position, Rotation, Scale) vec3 quat vec3 tuple
-Matrix4x4 Matrix4x4::fromPRS(const Vec3 &positionv, const Quaternion &rotv, const Vec3 &scalev) {
-	Matrix4x4 newM;
-	newM.setIdentity();
-	Matrix4x4 rot, scale;
-	rotv.toMatrix(&rot);
-	scale.setScaling(scalev);
-	newM = rot * scale;
-	newM.wx = positionv.x;
-	newM.wy = positionv.y;
-	newM.wz = positionv.z;
-	return newM;
-}
-
 void Matrix4x4::toText(char *buffer, int len) const {
 	snprintf(buffer, len, "%f %f %f %f\n%f %f %f %f\n%f %f %f %f\n%f %f %f %f\n",
 		xx,xy,xz,xw,

ext/native/math/lin/matrix4x4.h

@@ -35,7 +35,6 @@ public:
 		wx = v.x; wy = v.y; wz = v.z;
 	}
 
-
 	const float &operator[](int i) const {
 		return *(((const float *)this) + i);
 	}
@@ -56,13 +55,6 @@ public:
 		empty();
 		xx=yy=zz=f; ww=1.0f;
 	}
-	void setScaling(const Vec3 f) {
-		empty();
-		xx=f.x;
-		yy=f.y;
-		zz=f.z;
-		ww=1.0f;
-	}
 
 	void setIdentity() {
 		setScaling(1.0f);
@@ -73,12 +65,6 @@ public:
 		wy = trans.y;
 		wz = trans.z;
 	}
-	void setTranslationAndScaling(const Vec3 &trans, const Vec3 &scale) {
-		setScaling(scale);
-		wx = trans.x;
-		wy = trans.y;
-		wz = trans.z;
-	}
 
 	Matrix4x4 inverse() const;
 	Matrix4x4 simpleInverse() const;
@@ -86,69 +72,72 @@ public:
 
 	void setRotationX(const float a) {
 		empty();
-		float c=cosf(a);
-		float s=sinf(a);
+		float c = cosf(a);
+		float s = sinf(a);
 		xx = 1.0f;
-		yy =	c;			yz = s;
-		zy = -s;			zz = c;
+		yy = c; yz = s;
+		zy = -s; zz = c;
 		ww = 1.0f;
 	}
 	void setRotationY(const float a)	 {
 		empty();
-		float c=cosf(a);
-		float s=sinf(a);
-		xx = c;									 xz = -s;
-		yy =	1.0f;
-		zx = s;									 zz = c	;
+		float c = cosf(a);
+		float s = sinf(a);
+		xx = c; xz = -s;
+		yy = 1.0f;
+		zx = s; zz = c;
 		ww = 1.0f;
 	}
 	void setRotationZ(const float a)	 {
 		empty();
-		float c=cosf(a);
-		float s=sinf(a);
-		xx = c;		xy = s;
-		yx = -s;	 yy = c;
+		float c = cosf(a);
+		float s = sinf(a);
+		xx = c; xy = s;
+		yx = -s; yy = c;
 		zz = 1.0f; 
 		ww = 1.0f;
 	}
-	void setRotationAxisAngle(const Vec3 &axis, float angle);
-
+	// Exact angles to avoid any artifacts.
+	void setRotationZ90() {
+		empty();
+		float c = 0.0f;
+		float s = 1.0f;
+		xx = c; xy = s;
+		yx = -s; yy = c;
+		zz = 1.0f;
+		ww = 1.0f;
+	}
+	void setRotationZ180() {
+		empty();
+		float c = -1.0f;
+		float s = 0.0f;
+		xx = c; xy = s;
+		yx = -s; yy = c;
+		zz = 1.0f;
+		ww = 1.0f;
+	}
+	void setRotationZ270() {
+		empty();
+		float c = 0.0f;
+		float s = -1.0f;
+		xx = c; xy = s;
+		yx = -s; yy = c;
+		zz = 1.0f;
+		ww = 1.0f;
+	}
 
 	void setRotation(float x,float y, float z);
 	void setProjection(float near_plane, float far_plane, float fov_horiz, float aspect = 0.75f);
 	void setProjectionD3D(float near_plane, float far_plane, float fov_horiz, float aspect = 0.75f);
-	void setProjectionInf(float near_plane, float fov_horiz, float aspect = 0.75f);
 	void setOrtho(float left, float right, float bottom, float top, float near, float far);
 	void setOrthoD3D(float left, float right, float bottom, float top, float near, float far);
 	void setOrthoVulkan(float left, float right, float top, float bottom, float near, float far);
-	void setShadow(float Lx, float Ly, float Lz, float Lw) {
-		float Pa=0;
-		float Pb=1;
-		float Pc=0;
-		float Pd=0;
-		//P = normalize(Plane);
-		float d = (Pa*Lx + Pb*Ly + Pc*Lz + Pd*Lw);
-
-		xx=Pa * Lx + d;	xy=Pa * Ly;		 xz=Pa * Lz;		 xw=Pa * Lw;
-		yx=Pb * Lx;			yy=Pb * Ly + d; yz=Pb * Lz;		 yw=Pb * Lw;
-		zx=Pc * Lx;			zy=Pc * Ly;		 zz=Pc * Lz + d; zw=Pc * Lw;
-		wx=Pd * Lx;			wy=Pd * Ly;		 wz=Pd * Lz;		 ww=Pd * Lw + d;
-	}
 
 	void setViewLookAt(const Vec3 &from, const Vec3 &at, const Vec3 &worldup);
 	void setViewLookAtD3D(const Vec3 &from, const Vec3 &at, const Vec3 &worldup);
 	void setViewFrame(const Vec3 &pos, const Vec3 &right, const Vec3 &forward, const Vec3 &up);
-	void stabilizeOrtho() {
-		/*
-		front().normalize();
-		right().normalize();
-		up() = front() % right();
-		right() = up() % front();
-		*/
-	}
 	void toText(char *buffer, int len) const;
 	void print() const;
-	static Matrix4x4 fromPRS(const Vec3 &position, const Quaternion &normal, const Vec3 &scale);
 
 	void translateAndScale(const Vec3 &trans, const Vec3 &scale) {
 		xx = xx * scale.x + xw * trans.x;

ext/native/net/http_server.cpp

@@ -70,7 +70,7 @@ Request::~Request() {
 	delete out_;
 }
 
-void Request::WriteHttpResponseHeader(int status, int64_t size, const char *mimeType, const char *otherHeaders) const {
+void Request::WriteHttpResponseHeader(const char *ver, int status, int64_t size, const char *mimeType, const char *otherHeaders) const {
 	const char *statusStr;
 	switch (status) {
 	case 200: statusStr = "OK"; break;
@@ -92,7 +92,7 @@ void Request::WriteHttpResponseHeader(int status, int64_t size, const char *mime
 	}
 
 	net::OutputSink *buffer = Out();
-	buffer->Printf("HTTP/1.0 %03d %s\r\n", status, statusStr);
+	buffer->Printf("HTTP/%s %03d %s\r\n", ver, status, statusStr);
 	buffer->Push("Server: PPSSPPServer v0.1\r\n");
 	if (!mimeType || strcmp(mimeType, "websocket") != 0) {
 		buffer->Printf("Content-Type: %s\r\n", mimeType ? mimeType : DEFAULT_MIME_TYPE);
@@ -313,12 +313,12 @@ void Server::HandleRequestDefault(const Request &request) {
 void Server::Handle404(const Request &request) {
 	ILOG("No handler for '%s', falling back to 404.", request.resource());
 	const char *payload = "<html><body>404 not found</body></html>\r\n";
-	request.WriteHttpResponseHeader(404, (int)strlen(payload));
+	request.WriteHttpResponseHeader("1.0", 404, (int)strlen(payload));
 	request.Out()->Push(payload);
 }
 
 void Server::HandleListing(const Request &request) {
-	request.WriteHttpResponseHeader(200, -1, "text/plain");
+	request.WriteHttpResponseHeader("1.0", 200, -1, "text/plain");
 	for (auto iter = handlers_.begin(); iter != handlers_.end(); ++iter) {
 		request.Out()->Printf("%s\n", iter->first.c_str());
 	}

ext/native/net/http_server.h

@@ -50,7 +50,7 @@ class Request {
   bool IsOK() const { return fd_ > 0; }
 
   // If size is negative, no Content-Length: line is written.
-  void WriteHttpResponseHeader(int status, int64_t size = -1, const char *mimeType = nullptr, const char *otherHeaders = nullptr) const;
+  void WriteHttpResponseHeader(const char *ver, int status, int64_t size = -1, const char *mimeType = nullptr, const char *otherHeaders = nullptr) const;
 
 private:
 	net::InputSink *in_;

ext/native/net/websocket_server.cpp

@@ -90,12 +90,12 @@ WebSocketServer *WebSocketServer::CreateAsUpgrade(const http::Request &request,
 	};
 
 	if (!requireHeader("upgrade", "websocket") || !requireHeaderContains("connection", "upgrade")) {
-		request.WriteHttpResponseHeader(400, -1, "text/plain");
+		request.WriteHttpResponseHeader("1.1", 400, -1, "text/plain");
 		request.Out()->Push("Must send a websocket request.");
 		return nullptr;
 	}
 	if (!requireHeader("sec-websocket-version", "13")) {
-		request.WriteHttpResponseHeader(400, -1, "text/plain", "Sec-WebSocket-Version: 13\r\n");
+		request.WriteHttpResponseHeader("1.1", 400, -1, "text/plain", "Sec-WebSocket-Version: 13\r\n");
 		request.Out()->Push("Unsupported version.");
 		return nullptr;
 	}
@@ -110,7 +110,7 @@ WebSocketServer *WebSocketServer::CreateAsUpgrade(const http::Request &request,
 
 	std::string key;
 	if (!request.GetHeader("sec-websocket-key", &key)) {
-		request.WriteHttpResponseHeader(400, -1, "text/plain");
+		request.WriteHttpResponseHeader("1.1", 400, -1, "text/plain");
 		request.Out()->Push("Cannot accept without key.");
 		return nullptr;
 	}
@@ -123,7 +123,7 @@ WebSocketServer *WebSocketServer::CreateAsUpgrade(const http::Request &request,
 	std::string otherHeaders = StringFromFormat("Upgrade: websocket\r\nConnection: Upgrade\r\nSec-WebSocket-Accept: %s\r\n%s", acceptKey.c_str(), obtainedProtocolHeader.c_str());
 
 	// Okay, we're good to go then.
-	request.WriteHttpResponseHeader(101, -1, "websocket", otherHeaders.c_str());
+	request.WriteHttpResponseHeader("1.1", 101, -1, "websocket", otherHeaders.c_str());
 	request.WritePartial();
 
 	return new WebSocketServer(request.fd(), request.In(), request.Out());

ext/native/thin3d/thin3d.cpp

@@ -3,6 +3,7 @@
 #include <cstdint>
 
 #include "base/logging.h"
+#include "base/display.h"
 #include "thin3d/thin3d.h"
 #include "Common/Log.h"
 #include "Common/ColorConv.h"
@@ -352,6 +353,38 @@ DrawContext::~DrawContext() {
 	DestroyPresets();
 }
 
+void DrawContext::RotateRectToDisplay(FRect &rect, float curRTWidth, float curRTHeight) {
+	if (g_display_rotation == DisplayRotation::ROTATE_0)
+		return;
+	switch (g_display_rotation) {
+	case DisplayRotation::ROTATE_180:
+		rect.x = curRTWidth - rect.w - rect.x;
+		rect.y = curRTHeight - rect.h - rect.y;
+		break;
+	case DisplayRotation::ROTATE_90: {
+		// Note that curRTWidth_ and curRTHeight_ are "swapped"!
+		float origX = rect.x;
+		float origY = rect.y;
+		float rtw = curRTHeight;
+		float rth = curRTWidth;
+		rect.x = rth - rect.h - origY;
+		rect.y = origX;
+		std::swap(rect.w, rect.h);
+		break;
+	}
+	case DisplayRotation::ROTATE_270: {
+		float origX = rect.x;
+		float origY = rect.y;
+		float rtw = curRTHeight;
+		float rth = curRTWidth;
+		rect.x = origY;
+		rect.y = rtw - rect.w - origX;
+		std::swap(rect.w, rect.h);
+		break;
+	}
+	}
+}
+
 // TODO: SSE/NEON
 // Could also make C fake-simd for 64-bit, two 8888 pixels fit in a register :)
 void ConvertFromRGBA8888(uint8_t *dst, const uint8_t *src, uint32_t dstStride, uint32_t srcStride, uint32_t width, uint32_t height, DataFormat format) {

ext/native/thin3d/thin3d.h

@@ -661,6 +661,11 @@ public:
 	virtual void FlushState() {}
 
 protected:
+	struct FRect {
+		float x, y, w, h;
+	};
+	void RotateRectToDisplay(FRect &rect, float curRTWidth, float curRTHeight);
+
 	ShaderModule *vsPresets_[VS_MAX_PRESET];
 	ShaderModule *fsPresets_[FS_MAX_PRESET];
 

ext/native/thin3d/thin3d_d3d11.cpp

@@ -159,12 +159,7 @@ public:
 	void HandleEvent(Event ev, int width, int height, void *param1, void *param2) override;
 
 private:
-	struct FRect {
-		float x, y, w, h;
-	};
-
 	void ApplyCurrentState();
-	void RotateRectToDisplay(FRect &rect);
 
 	HWND hWnd_;
 	ID3D11Device *device_;
@@ -362,42 +357,12 @@ void D3D11DrawContext::HandleEvent(Event ev, int width, int height, void *param1
 	}
 }
 
-void D3D11DrawContext::RotateRectToDisplay(FRect &rect) {
-	if (g_display_rotation == DisplayRotation::ROTATE_0)
-		return;
-	if (curRenderTargetView_ != bbRenderTargetView_)
-		return;  // Only the backbuffer is actually rotated wrong!
-	switch (g_display_rotation) {
-	case DisplayRotation::ROTATE_180:
-		rect.x = curRTWidth_ - rect.w - rect.x;
-		rect.y = curRTHeight_ - rect.h - rect.y;
-		break;
-	case DisplayRotation::ROTATE_90: {
-		// Note that curRTWidth_ and curRTHeight_ are "swapped"!
-		float origX = rect.x;
-		float origY = rect.y;
-		float rtw = curRTHeight_;
-		float rth = curRTWidth_;
-		rect.x = rth - rect.h - origY;
-		rect.y = origX;
-		std::swap(rect.w, rect.h);
-		break;
-	}
-	case DisplayRotation::ROTATE_270: {
-		float origX = rect.x;
-		float origY = rect.y;
-		// TODO
-		std::swap(rect.w, rect.h);
-		break;
-	}
-	}
-}
-
 void D3D11DrawContext::SetViewports(int count, Viewport *viewports) {
 	D3D11_VIEWPORT vp[4];
 	for (int i = 0; i < count; i++) {
 		FRect rc{ viewports[i].TopLeftX , viewports[i].TopLeftY, viewports[i].Width, viewports[i].Height };
-		RotateRectToDisplay(rc);
+		if (curRenderTargetView_ == bbRenderTargetView_)  // Only the backbuffer is actually rotated wrong!
+			RotateRectToDisplay(rc, curRTWidth_, curRTHeight_);
 		vp[i].TopLeftX = rc.x;
 		vp[i].TopLeftY = rc.y;
 		vp[i].Width = rc.w;
@@ -410,8 +375,8 @@ void D3D11DrawContext::SetViewports(int count, Viewport *viewports) {
 
 void D3D11DrawContext::SetScissorRect(int left, int top, int width, int height) {
 	FRect frc{ (float)left, (float)top, (float)width, (float)height };
-	RotateRectToDisplay(frc);
-
+	if (curRenderTargetView_ == bbRenderTargetView_)  // Only the backbuffer is actually rotated wrong!
+		RotateRectToDisplay(frc, curRTWidth_, curRTHeight_);
 	D3D11_RECT rc{};
 	rc.left = (INT)frc.x;
 	rc.top = (INT)frc.y;

ext/native/thin3d/thin3d_vulkan.cpp

@@ -1059,17 +1059,30 @@ Pipeline *VKContext::CreateGraphicsPipeline(const PipelineDesc &desc) {
 }
 
 void VKContext::SetScissorRect(int left, int top, int width, int height) {
-	VkRect2D scissor{ {left, top}, {(uint32_t)width, (uint32_t)height} };
+	FRect rc{ (float)left, (float)top, (float)width, (float)height };
+	if (curFramebuffer_ == nullptr) { // Only the backbuffer is actually rotated wrong!
+		int curRTWidth, curRTHeight;
+		GetFramebufferDimensions((Framebuffer *)curFramebuffer_, &curRTWidth, &curRTHeight);
+		RotateRectToDisplay(rc, (float)curRTWidth, (float)curRTHeight);
+	}
+	VkRect2D scissor{ {(int32_t)rc.x, (int32_t)rc.y}, {(uint32_t)rc.w, (uint32_t)rc.h} };
 	renderManager_.SetScissor(scissor);
 }
 
 void VKContext::SetViewports(int count, Viewport *viewports) {
 	if (count > 0) {
+		// Ignore viewports more than the first.
 		VkViewport viewport;
-		viewport.x = viewports[0].TopLeftX;
-		viewport.y = viewports[0].TopLeftY;
-		viewport.width = viewports[0].Width;
-		viewport.height = viewports[0].Height;
+		FRect rc{ viewports[0].TopLeftX , viewports[0].TopLeftY, viewports[0].Width, viewports[0].Height };
+		if (curFramebuffer_ == nullptr) { // Only the backbuffer is actually rotated wrong!
+			int curRTWidth, curRTHeight;
+			GetFramebufferDimensions((Framebuffer *)curFramebuffer_, &curRTWidth, &curRTHeight);
+			RotateRectToDisplay(rc, (float)curRTWidth, (float)curRTHeight);
+		}
+		viewport.x = rc.x;
+		viewport.y = rc.y;
+		viewport.width = rc.w;
+		viewport.height = rc.h;
 		viewport.minDepth = viewports[0].MinDepth;
 		viewport.maxDepth = viewports[0].MaxDepth;
 		renderManager_.SetViewport(viewport);

ext/vulkan/vk_icd.h

@@ -88,7 +88,8 @@ typedef enum {
     VK_ICD_WSI_PLATFORM_ANDROID,
     VK_ICD_WSI_PLATFORM_MACOS,
     VK_ICD_WSI_PLATFORM_IOS,
-    VK_ICD_WSI_PLATFORM_DISPLAY
+    VK_ICD_WSI_PLATFORM_DISPLAY,
+    VK_ICD_WSI_PLATFORM_HEADLESS
 } VkIcdWsiPlatform;
 
 typedef struct {
@@ -167,4 +168,8 @@ typedef struct {
     VkExtent2D imageExtent;
 } VkIcdSurfaceDisplay;
 
+typedef struct {
+    VkIcdSurfaceBase base;
+} VkIcdSurfaceHeadless;
+
 #endif  // VKICD_H

ext/vulkan/vk_layer.h

@@ -82,7 +82,8 @@ typedef VkResult(VKAPI_PTR *PFN_PhysDevExt)(VkPhysicalDevice phys_device);
  */
 typedef enum VkLayerFunction_ {
     VK_LAYER_LINK_INFO = 0,
-    VK_LOADER_DATA_CALLBACK = 1
+    VK_LOADER_DATA_CALLBACK = 1,
+    VK_LOADER_LAYER_CREATE_DEVICE_CALLBACK = 2
 } VkLayerFunction;
 
 typedef struct VkLayerInstanceLink_ {
@@ -107,7 +108,9 @@ 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 struct {
     VkStructureType sType; // VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO
     const void *pNext;
@@ -115,6 +118,10 @@ typedef struct {
     union {
         VkLayerInstanceLink *pLayerInfo;
         PFN_vkSetInstanceLoaderData pfnSetInstanceLoaderData;
+        struct {
+	  PFN_vkLayerCreateDevice pfnLayerCreateDevice;
+	  PFN_vkLayerDestroyDevice pfnLayerDestroyDevice;
+	} layerDevice;
     } u;
 } VkLayerInstanceCreateInfo;
 

ext/vulkan/vulkan.h

@@ -38,6 +38,9 @@
 #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"
@@ -74,4 +77,10 @@
 #include "vulkan_xlib_xrandr.h"
 #endif
 
+
+#ifdef VK_USE_PLATFORM_GGP
+#include <ggp_c/vulkan_types.h>
+#include "vulkan_ggp.h"
+#endif
+
 #endif // VULKAN_H_

ext/vulkan/vulkan_android.h

@@ -27,14 +27,12 @@ extern "C" {
 */
 
 
+
 #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;
@@ -42,7 +40,6 @@ typedef struct VkAndroidSurfaceCreateInfoKHR {
     struct ANativeWindow*             window;
 } VkAndroidSurfaceCreateInfoKHR;
 
-
 typedef VkResult (VKAPI_PTR *PFN_vkCreateAndroidSurfaceKHR)(VkInstance instance, const VkAndroidSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface);
 
 #ifndef VK_NO_PROTOTYPES
@@ -53,12 +50,11 @@ VKAPI_ATTR VkResult VKAPI_CALL vkCreateAndroidSurfaceKHR(
     VkSurfaceKHR*                               pSurface);
 #endif
 
+
 #define VK_ANDROID_external_memory_android_hardware_buffer 1
 struct AHardwareBuffer;
-
 #define VK_ANDROID_EXTERNAL_MEMORY_ANDROID_HARDWARE_BUFFER_SPEC_VERSION 3
 #define VK_ANDROID_EXTERNAL_MEMORY_ANDROID_HARDWARE_BUFFER_EXTENSION_NAME "VK_ANDROID_external_memory_android_hardware_buffer"
-
 typedef struct VkAndroidHardwareBufferUsageANDROID {
     VkStructureType    sType;
     void*              pNext;
@@ -103,7 +99,6 @@ typedef struct VkExternalFormatANDROID {
     uint64_t           externalFormat;
 } VkExternalFormatANDROID;
 
-
 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);
 

ext/vulkan/vulkan_fuchsia.h

@@ -27,12 +27,11 @@ extern "C" {
 */
 
 
+
 #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;
@@ -40,7 +39,6 @@ typedef struct VkImagePipeSurfaceCreateInfoFUCHSIA {
     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

ext/vulkan/vulkan_ggp.h

@@ -0,0 +1,67 @@
+#ifndef VULKAN_GGP_H_
+#define VULKAN_GGP_H_ 1
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+** Copyright (c) 2015-2019 The Khronos Group 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.
+*/
+
+/*
+** This header is generated from the Khronos Vulkan XML API Registry.
+**
+*/
+
+
+
+#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

ext/vulkan/vulkan_ios.h

@@ -27,12 +27,11 @@ extern "C" {
 */
 
 
+
 #define VK_MVK_ios_surface 1
 #define VK_MVK_IOS_SURFACE_SPEC_VERSION   2
 #define VK_MVK_IOS_SURFACE_EXTENSION_NAME "VK_MVK_ios_surface"
-
 typedef VkFlags VkIOSSurfaceCreateFlagsMVK;
-
 typedef struct VkIOSSurfaceCreateInfoMVK {
     VkStructureType               sType;
     const void*                   pNext;
@@ -40,7 +39,6 @@ typedef struct VkIOSSurfaceCreateInfoMVK {
     const void*                   pView;
 } VkIOSSurfaceCreateInfoMVK;
 
-
 typedef VkResult (VKAPI_PTR *PFN_vkCreateIOSSurfaceMVK)(VkInstance instance, const VkIOSSurfaceCreateInfoMVK* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface);
 
 #ifndef VK_NO_PROTOTYPES

ext/vulkan/vulkan_macos.h

@@ -27,12 +27,11 @@ extern "C" {
 */
 
 
+
 #define VK_MVK_macos_surface 1
 #define VK_MVK_MACOS_SURFACE_SPEC_VERSION 2
 #define VK_MVK_MACOS_SURFACE_EXTENSION_NAME "VK_MVK_macos_surface"
-
 typedef VkFlags VkMacOSSurfaceCreateFlagsMVK;
-
 typedef struct VkMacOSSurfaceCreateInfoMVK {
     VkStructureType                 sType;
     const void*                     pNext;
@@ -40,7 +39,6 @@ typedef struct VkMacOSSurfaceCreateInfoMVK {
     const void*                     pView;
 } VkMacOSSurfaceCreateInfoMVK;
 
-
 typedef VkResult (VKAPI_PTR *PFN_vkCreateMacOSSurfaceMVK)(VkInstance instance, const VkMacOSSurfaceCreateInfoMVK* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface);
 
 #ifndef VK_NO_PROTOTYPES

ext/vulkan/vulkan_metal.h

@@ -0,0 +1,63 @@
+#ifndef VULKAN_METAL_H_
+#define VULKAN_METAL_H_ 1
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+** Copyright (c) 2015-2019 The Khronos Group 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.
+*/
+
+/*
+** This header is generated from the Khronos Vulkan XML API Registry.
+**
+*/
+
+
+
+#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
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

ext/vulkan/vulkan_mir.h

@@ -1,65 +0,0 @@
-#ifndef VULKAN_MIR_H_
-#define VULKAN_MIR_H_ 1
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/*
-** Copyright (c) 2015-2018 The Khronos Group 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.
-*/
-
-/*
-** This header is generated from the Khronos Vulkan XML API Registry.
-**
-*/
-
-
-#define VK_KHR_mir_surface 1
-#define VK_KHR_MIR_SURFACE_SPEC_VERSION   4
-#define VK_KHR_MIR_SURFACE_EXTENSION_NAME "VK_KHR_mir_surface"
-
-typedef VkFlags VkMirSurfaceCreateFlagsKHR;
-
-typedef struct VkMirSurfaceCreateInfoKHR {
-    VkStructureType               sType;
-    const void*                   pNext;
-    VkMirSurfaceCreateFlagsKHR    flags;
-    MirConnection*                connection;
-    MirSurface*                   mirSurface;
-} VkMirSurfaceCreateInfoKHR;
-
-
-typedef VkResult (VKAPI_PTR *PFN_vkCreateMirSurfaceKHR)(VkInstance instance, const VkMirSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface);
-typedef VkBool32 (VKAPI_PTR *PFN_vkGetPhysicalDeviceMirPresentationSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, MirConnection* connection);
-
-#ifndef VK_NO_PROTOTYPES
-VKAPI_ATTR VkResult VKAPI_CALL vkCreateMirSurfaceKHR(
-    VkInstance                                  instance,
-    const VkMirSurfaceCreateInfoKHR*            pCreateInfo,
-    const VkAllocationCallbacks*                pAllocator,
-    VkSurfaceKHR*                               pSurface);
-
-VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceMirPresentationSupportKHR(
-    VkPhysicalDevice                            physicalDevice,
-    uint32_t                                    queueFamilyIndex,
-    MirConnection*                              connection);
-#endif
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif

ext/vulkan/vulkan_vi.h

@@ -27,12 +27,11 @@ extern "C" {
 */
 
 
+
 #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;
@@ -40,7 +39,6 @@ typedef struct VkViSurfaceCreateInfoNN {
     void*                       window;
 } VkViSurfaceCreateInfoNN;
 
-
 typedef VkResult (VKAPI_PTR *PFN_vkCreateViSurfaceNN)(VkInstance instance, const VkViSurfaceCreateInfoNN* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface);
 
 #ifndef VK_NO_PROTOTYPES

ext/vulkan/vulkan_wayland.h

@@ -27,12 +27,11 @@ extern "C" {
 */
 
 
+
 #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;
@@ -41,7 +40,6 @@ typedef struct VkWaylandSurfaceCreateInfoKHR {
     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);
 

ext/vulkan/vulkan_win32.h

@@ -27,12 +27,11 @@ extern "C" {
 */
 
 
+
 #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;
@@ -41,7 +40,6 @@ typedef struct VkWin32SurfaceCreateInfoKHR {
     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);
 
@@ -57,10 +55,10 @@ VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceWin32PresentationSupportKHR(
     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;
@@ -90,7 +88,6 @@ typedef struct VkMemoryGetWin32HandleInfoKHR {
     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);
 
@@ -107,10 +104,10 @@ VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryWin32HandlePropertiesKHR(
     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;
@@ -128,7 +125,6 @@ typedef struct 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;
@@ -163,7 +159,6 @@ typedef struct VkSemaphoreGetWin32HandleInfoKHR {
     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);
 
@@ -178,10 +173,10 @@ VKAPI_ATTR VkResult VKAPI_CALL vkGetSemaphoreWin32HandleKHR(
     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;
@@ -207,7 +202,6 @@ typedef struct VkFenceGetWin32HandleInfoKHR {
     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);
 
@@ -222,10 +216,10 @@ VKAPI_ATTR VkResult VKAPI_CALL vkGetFenceWin32HandleKHR(
     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;
@@ -240,7 +234,6 @@ typedef struct VkExportMemoryWin32HandleInfoNV {
     DWORD                         dwAccess;
 } VkExportMemoryWin32HandleInfoNV;
 
-
 typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryWin32HandleNV)(VkDevice device, VkDeviceMemory memory, VkExternalMemoryHandleTypeFlagsNV handleType, HANDLE* pHandle);
 
 #ifndef VK_NO_PROTOTYPES
@@ -251,10 +244,10 @@ VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryWin32HandleNV(
     HANDLE*                                     pHandle);
 #endif
 
+
 #define VK_NV_win32_keyed_mutex 1
 #define VK_NV_WIN32_KEYED_MUTEX_SPEC_VERSION 1
 #define VK_NV_WIN32_KEYED_MUTEX_EXTENSION_NAME "VK_NV_win32_keyed_mutex"
-
 typedef struct VkWin32KeyedMutexAcquireReleaseInfoNV {
     VkStructureType          sType;
     const void*              pNext;
@@ -269,6 +262,64 @@ typedef struct VkWin32KeyedMutexAcquireReleaseInfoNV {
 
 
 
+#define VK_EXT_full_screen_exclusive 1
+#define VK_EXT_FULL_SCREEN_EXCLUSIVE_SPEC_VERSION 3
+#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_BEGIN_RANGE_EXT = VK_FULL_SCREEN_EXCLUSIVE_DEFAULT_EXT,
+    VK_FULL_SCREEN_EXCLUSIVE_END_RANGE_EXT = VK_FULL_SCREEN_EXCLUSIVE_APPLICATION_CONTROLLED_EXT,
+    VK_FULL_SCREEN_EXCLUSIVE_RANGE_SIZE_EXT = (VK_FULL_SCREEN_EXCLUSIVE_APPLICATION_CONTROLLED_EXT - VK_FULL_SCREEN_EXCLUSIVE_DEFAULT_EXT + 1),
+    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

ext/vulkan/vulkan_xcb.h

@@ -27,12 +27,11 @@ extern "C" {
 */
 
 
+
 #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;
@@ -41,7 +40,6 @@ typedef struct VkXcbSurfaceCreateInfoKHR {
     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);
 

ext/vulkan/vulkan_xlib.h

@@ -27,12 +27,11 @@ extern "C" {
 */
 
 
+
 #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;
@@ -41,7 +40,6 @@ typedef struct VkXlibSurfaceCreateInfoKHR {
     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);
 

ext/vulkan/vulkan_xlib_xrandr.h

@@ -27,10 +27,10 @@ extern "C" {
 */
 
 
+
 #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);
 

libretro/Makefile.common

@@ -248,7 +248,9 @@ SOURCES_CXX += \
 	$(EXTDIR)/SPIRV-Cross/spirv_cross.cpp \
 	$(EXTDIR)/SPIRV-Cross/spirv_cross_util.cpp \
 	$(EXTDIR)/SPIRV-Cross/spirv_glsl.cpp \
-   $(EXTDIR)/SPIRV-Cross/spirv_hlsl.cpp
+	$(EXTDIR)/SPIRV-Cross/spirv_hlsl.cpp \
+	$(EXTDIR)/SPIRV-Cross/spirv_parser.cpp \
+	$(EXTDIR)/SPIRV-Cross/spirv_cross_parsed_ir.cpp
 
 ifeq ($(PLATFORM_EXT), win32)
 SOURCES_CXX += $(COMMONDIR)/MemArenaWin32.cpp \