Bump version to 1.1.1

Mac version 1.1.0

.gitignore

@@ -20,6 +20,7 @@
 *.idb
 *.aps
 *.res
+*.a
 .vs/*
 Packaged/*
 DebugData/*
@@ -30,9 +31,33 @@ InstallerPackages/*
 *.wixobj
 *.CopyComplete
 *.lnk
+*.cmake
 ReleasePackageInstaller/obj/*
 ReleasePackageInstaller/bin/*
 ReleasePackageInstaller/AerofoilPackageDefs.wxi
 ReleasePackageInstaller/AerofoilPackageVersion.wxi
 packages/*
 !SDL2-2.0.12/lib/x64/*
+CMakeCache.txt
+CMakeFiles/*
+Makefile
+SDL2-2.0.12/CMakeFiles/*
+SDL2-2.0.12/build
+SDL2-2.0.12/config.status
+SDL2-2.0.12/libtool
+SDL2-2.0.12/Makefile.rules
+SDL2-2.0.12/sdl2.pc
+SDL2-2.0.12/sdl2-config
+install_manifest.txt
+
+
+## Xcode projects
+AerofoilMac/xcuserdata/
+AerofoilMac/*.xcodeproj/xcuserdata/
+AerofoilMac/build/
+AerofoilMac/DerivedData/
+*.xcuserstate
+SDL2-2.0.12/Xcode/SDL/SDL.xcodeproj/xcuserdata/*
+AerofoilMac/Resources/*.gpf
+AerofoilMac/Resources/Houses/*.gpf
+AerofoilMac/*.xcodeproj/project.xcworkspace/xcuserdata

.gitmodules

@@ -0,0 +1,4 @@
+[submodule "AerofoilWeb/FileSaverDotJS"]
+	path = AerofoilWeb/FileSaverDotJS
+	url = https://github.com/eligrey/FileSaver.js.git
+	branch = master

.vscode/settings.json

@@ -0,0 +1,66 @@
+{
+    "files.associations": {
+        "iostream": "cpp",
+        "array": "cpp",
+        "atomic": "cpp",
+        "bit": "cpp",
+        "*.tcc": "cpp",
+        "bitset": "cpp",
+        "cctype": "cpp",
+        "chrono": "cpp",
+        "clocale": "cpp",
+        "cmath": "cpp",
+        "codecvt": "cpp",
+        "compare": "cpp",
+        "complex": "cpp",
+        "concepts": "cpp",
+        "condition_variable": "cpp",
+        "cstdarg": "cpp",
+        "cstddef": "cpp",
+        "cstdint": "cpp",
+        "cstdio": "cpp",
+        "cstdlib": "cpp",
+        "cstring": "cpp",
+        "ctime": "cpp",
+        "cwchar": "cpp",
+        "cwctype": "cpp",
+        "deque": "cpp",
+        "map": "cpp",
+        "unordered_map": "cpp",
+        "vector": "cpp",
+        "exception": "cpp",
+        "algorithm": "cpp",
+        "functional": "cpp",
+        "iterator": "cpp",
+        "memory": "cpp",
+        "memory_resource": "cpp",
+        "numeric": "cpp",
+        "optional": "cpp",
+        "random": "cpp",
+        "ratio": "cpp",
+        "regex": "cpp",
+        "string": "cpp",
+        "string_view": "cpp",
+        "system_error": "cpp",
+        "tuple": "cpp",
+        "type_traits": "cpp",
+        "utility": "cpp",
+        "fstream": "cpp",
+        "initializer_list": "cpp",
+        "iosfwd": "cpp",
+        "istream": "cpp",
+        "limits": "cpp",
+        "mutex": "cpp",
+        "new": "cpp",
+        "ostream": "cpp",
+        "ranges": "cpp",
+        "shared_mutex": "cpp",
+        "sstream": "cpp",
+        "stdexcept": "cpp",
+        "stop_token": "cpp",
+        "streambuf": "cpp",
+        "thread": "cpp",
+        "cinttypes": "cpp",
+        "typeinfo": "cpp"
+    }
+}

Aerofoil.sln

@@ -46,6 +46,11 @@ EndProject
 Project("{930C7802-8A8C-48F9-8165-68863BCCD9DD}") = "ReleasePackageInstaller", "ReleasePackageInstaller\ReleasePackageInstaller.wixproj", "{D26BD501-28A7-4849-8130-FB5EA0A2B82F}"
 	ProjectSection(ProjectDependencies) = postProject
 		{7EFF1E21-C375-45EA-A069-4E2232C8A72B} = {7EFF1E21-C375-45EA-A069-4E2232C8A72B}
+		{B852D549-4020-4477-8BFB-E199FF78B047} = {B852D549-4020-4477-8BFB-E199FF78B047}
+		{2FF15659-5C72-48B8-B55B-3C658E4125B5} = {2FF15659-5C72-48B8-B55B-3C658E4125B5}
+		{3B7FD18D-7A50-4DF5-AC25-543E539BFACE} = {3B7FD18D-7A50-4DF5-AC25-543E539BFACE}
+		{B31BFF9D-2D14-4B1A-A625-8348CC3D8D67} = {B31BFF9D-2D14-4B1A-A625-8348CC3D8D67}
+		{36DAF5FA-6ADB-4F20-9810-1610DE0AE653} = {36DAF5FA-6ADB-4F20-9810-1610DE0AE653}
 	EndProjectSection
 EndProject
 Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "WindowsUnicodeToolShim", "WindowsUnicodeToolShim\WindowsUnicodeToolShim.vcxproj", "{15009625-1120-405E-8BBA-69A16CD6713D}"
@@ -58,6 +63,14 @@ Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "GpFontHandler_FreeType2", "
 EndProject
 Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "AerofoilSDL", "AerofoilSDL\AerofoilSDL.vcxproj", "{33542FF0-0473-4802-BC79-3B8261790F65}"
 EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "MergeGPF", "MergeGPF\MergeGPF.vcxproj", "{36DAF5FA-6ADB-4F20-9810-1610DE0AE653}"
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "GenerateFonts", "GenerateFonts\GenerateFonts.vcxproj", "{3B7FD18D-7A50-4DF5-AC25-543E539BFACE}"
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "bin2h", "bin2h\bin2h.vcxproj", "{D045F28D-F245-44DD-B576-CC91BF3BE6E9}"
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "HouseTool", "HouseTool\HouseTool.vcxproj", "{B31BFF9D-2D14-4B1A-A625-8348CC3D8D67}"
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|x64 = Debug|x64
@@ -166,6 +179,22 @@ Global
 		{33542FF0-0473-4802-BC79-3B8261790F65}.Debug|x64.Build.0 = Debug|x64
 		{33542FF0-0473-4802-BC79-3B8261790F65}.Release|x64.ActiveCfg = Release|x64
 		{33542FF0-0473-4802-BC79-3B8261790F65}.Release|x64.Build.0 = Release|x64
+		{36DAF5FA-6ADB-4F20-9810-1610DE0AE653}.Debug|x64.ActiveCfg = Debug|x64
+		{36DAF5FA-6ADB-4F20-9810-1610DE0AE653}.Debug|x64.Build.0 = Debug|x64
+		{36DAF5FA-6ADB-4F20-9810-1610DE0AE653}.Release|x64.ActiveCfg = Release|x64
+		{36DAF5FA-6ADB-4F20-9810-1610DE0AE653}.Release|x64.Build.0 = Release|x64
+		{3B7FD18D-7A50-4DF5-AC25-543E539BFACE}.Debug|x64.ActiveCfg = Debug|x64
+		{3B7FD18D-7A50-4DF5-AC25-543E539BFACE}.Debug|x64.Build.0 = Debug|x64
+		{3B7FD18D-7A50-4DF5-AC25-543E539BFACE}.Release|x64.ActiveCfg = Release|x64
+		{3B7FD18D-7A50-4DF5-AC25-543E539BFACE}.Release|x64.Build.0 = Release|x64
+		{D045F28D-F245-44DD-B576-CC91BF3BE6E9}.Debug|x64.ActiveCfg = Debug|x64
+		{D045F28D-F245-44DD-B576-CC91BF3BE6E9}.Debug|x64.Build.0 = Debug|x64
+		{D045F28D-F245-44DD-B576-CC91BF3BE6E9}.Release|x64.ActiveCfg = Release|x64
+		{D045F28D-F245-44DD-B576-CC91BF3BE6E9}.Release|x64.Build.0 = Release|x64
+		{B31BFF9D-2D14-4B1A-A625-8348CC3D8D67}.Debug|x64.ActiveCfg = Debug|x64
+		{B31BFF9D-2D14-4B1A-A625-8348CC3D8D67}.Debug|x64.Build.0 = Debug|x64
+		{B31BFF9D-2D14-4B1A-A625-8348CC3D8D67}.Release|x64.ActiveCfg = Release|x64
+		{B31BFF9D-2D14-4B1A-A625-8348CC3D8D67}.Release|x64.Build.0 = Release|x64
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE

Aerofoil/Aerofoil.vcxproj

@@ -43,6 +43,7 @@
     <Import Project="..\GpMainApp.props" />
     <Import Project="..\GpShell.props" />
     <Import Project="..\Debug.props" />
+    <Import Project="..\AerofoilPortable.props" />
   </ImportGroup>
   <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
     <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
@@ -52,6 +53,7 @@
     <Import Project="..\GpMainApp.props" />
     <Import Project="..\Release.props" />
     <Import Project="..\GpShell.props" />
+    <Import Project="..\AerofoilPortable.props" />
   </ImportGroup>
   <PropertyGroup Label="UserMacros" />
   <PropertyGroup />
@@ -82,16 +84,15 @@
     </Link>
   </ItemDefinitionGroup>
   <ItemGroup>
+    <ClCompile Include="..\AerofoilPortable\GpAllocator_C.cpp" />
     <ClCompile Include="GpBWCursor_Win32.cpp" />
     <ClCompile Include="GpColorCursor_Win32.cpp" />
-    <ClCompile Include="GpFiber_Win32.cpp" />
     <ClCompile Include="GpFileStream_Win32.cpp" />
     <ClCompile Include="GpFileSystem_Win32.cpp" />
     <ClCompile Include="GpLogDriver_Win32.cpp" />
     <ClCompile Include="GpMain_Win32.cpp" />
     <ClCompile Include="GpMutex_Win32.cpp" />
     <ClCompile Include="GpSystemServices_Win32.cpp" />
-    <ClCompile Include="GpFiberStarter_Win32.cpp" />
     <ClCompile Include="GpThreadEvent_Win32.cpp" />
   </ItemGroup>
   <ItemGroup>
@@ -102,13 +103,14 @@
     <ClInclude Include="..\GpCommon\GpDisplayDriverTickStatus.h" />
     <ClInclude Include="..\GpCommon\GpFileCreationDisposition.h" />
     <ClInclude Include="..\GpCommon\GpInputDriverProperties.h" />
+    <ClInclude Include="..\GpCommon\GpString.h" />
+    <ClInclude Include="..\GpCommon\GpVector.h" />
     <ClInclude Include="..\GpCommon\IGpCursor.h" />
     <ClInclude Include="..\GpCommon\IGpAudioChannelCallbacks.h" />
     <ClInclude Include="..\GpCommon\IGpDisplayDriverSurface.h" />
     <ClInclude Include="..\GpCommon\IGpLogDriver.h" />
     <ClInclude Include="..\GpCommon\IGpPrefsHandler.h" />
     <ClInclude Include="GpBWCursor_Win32.h" />
-    <ClInclude Include="GpFiber_Win32.h" />
     <ClInclude Include="GpFileStream_Win32.h" />
     <ClInclude Include="GpFileSystem_Win32.h" />
     <ClInclude Include="GpLogDriver_Win32.h" />
@@ -127,9 +129,6 @@
     <ProjectReference Include="..\GpDisplayDriver_D3D11\GpDisplayDriver_D3D11.vcxproj">
       <Project>{ffc961ac-55b4-4a38-a83e-06ae98f59acc}</Project>
     </ProjectReference>
-    <ProjectReference Include="..\GpFontHandler_FreeType2\GpFontHandler_FreeType2.vcxproj">
-      <Project>{4b564030-8985-4975-91e1-e1b2c16ae2a1}</Project>
-    </ProjectReference>
     <ProjectReference Include="..\GpInputDriver_XInput\GpInputDriver_XInput.vcxproj">
       <Project>{17b96f07-ef92-47cd-95a5-8e6ee38ab564}</Project>
     </ProjectReference>

Aerofoil/Aerofoil.vcxproj.filters

@@ -4,12 +4,6 @@
     <ClCompile Include="GpColorCursor_Win32.cpp">
       <Filter>Source Files</Filter>
     </ClCompile>
-    <ClCompile Include="GpFiber_Win32.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="GpFiberStarter_Win32.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
     <ClCompile Include="GpFileStream_Win32.cpp">
       <Filter>Source Files</Filter>
     </ClCompile>
@@ -34,6 +28,9 @@
     <ClCompile Include="GpBWCursor_Win32.cpp">
       <Filter>Source Files</Filter>
     </ClCompile>
+    <ClCompile Include="..\AerofoilPortable\GpAllocator_C.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
   </ItemGroup>
   <ItemGroup>
     <ClInclude Include="..\GpCommon\EGpInputDriverType.h">
@@ -48,9 +45,6 @@
     <ClInclude Include="..\GpCommon\GpDisplayDriverTickStatus.h">
       <Filter>Header Files</Filter>
     </ClInclude>
-    <ClInclude Include="GpFiber_Win32.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
     <ClInclude Include="..\GpCommon\GpFileCreationDisposition.h">
       <Filter>Header Files</Filter>
     </ClInclude>
@@ -99,6 +93,12 @@
     <ClInclude Include="GpBWCursor_Win32.h">
       <Filter>Header Files</Filter>
     </ClInclude>
+    <ClInclude Include="..\GpCommon\GpVector.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\GpCommon\GpString.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
   </ItemGroup>
   <ItemGroup>
     <Image Include="ConvertedResources\Large128.ico">

Aerofoil/GpBWCursor_Win32.cpp

@@ -21,6 +21,7 @@
 
 #include "GpBWCursor_Win32.h"
 #include "GpWindows.h"
+#include "IGpAllocator.h"
 
 #include <stdint.h>
 #include <stdlib.h>
@@ -34,19 +35,19 @@ void GpBWCursor_Win32::Destroy()
 	this->DecRef();
 }
 
-IGpCursor_Win32 *GpBWCursor_Win32::Create(size_t width, size_t height, const void *pixelData, const void *maskData, size_t hotSpotX, size_t hotSpotY)
+IGpCursor_Win32 *GpBWCursor_Win32::Create(IGpAllocator *alloc, size_t width, size_t height, const void *pixelData, const void *maskData, size_t hotSpotX, size_t hotSpotY)
 {
 	size_t numBits = width * height;
-	size_t numBytes = (width * height + 7) / 8;
-	uint8_t *convertedAndData = static_cast<uint8_t*>(malloc(numBytes));
-	uint8_t *convertedXorData = static_cast<uint8_t*>(malloc(numBytes));
+	size_t numBytes = (numBits + 7) / 8;
+	uint8_t *convertedAndData = static_cast<uint8_t*>(alloc->Alloc(numBytes));
+	uint8_t *convertedXorData = static_cast<uint8_t*>(alloc->Alloc(numBytes));
 
 	if (!convertedAndData || !convertedXorData)
 	{
 		if (convertedAndData)
-			free(convertedAndData);
+			alloc->Release(convertedAndData);
 		if (convertedXorData)
-			free(convertedXorData);
+			alloc->Release(convertedXorData);
 
 		return nullptr;
 	}
@@ -62,25 +63,26 @@ IGpCursor_Win32 *GpBWCursor_Win32::Create(size_t width, size_t height, const voi
 
 	HCURSOR hcursor = CreateCursor(g_gpWindowsGlobals.m_hInstance, static_cast<int>(hotSpotX), static_cast<int>(hotSpotY), static_cast<int>(width), static_cast<int>(height), convertedAndData, convertedXorData);
 
-	free(convertedAndData);
-	free(convertedXorData);
+	alloc->Release(convertedAndData);
+	alloc->Release(convertedXorData);
 
 	if (!hcursor)
 		return nullptr;
 
-	void *storage = malloc(sizeof(GpBWCursor_Win32));
+	void *storage = alloc->Alloc(sizeof(GpBWCursor_Win32));
 	if (!storage)
 	{
 		DestroyCursor(hcursor);
 		return nullptr;
 	}
 
-	return new (storage) GpBWCursor_Win32(hcursor);
+	return new (storage) GpBWCursor_Win32(hcursor, alloc);
 }
 
-GpBWCursor_Win32::GpBWCursor_Win32(HCURSOR cursor)
+GpBWCursor_Win32::GpBWCursor_Win32(HCURSOR cursor, IGpAllocator *alloc)
 	: m_cursor(cursor)
 	, m_refCount(1)
+	, m_alloc(alloc)
 {
 }
 
@@ -104,7 +106,8 @@ void GpBWCursor_Win32::DecRef()
 	m_refCount--;
 	if (m_refCount == 0)
 	{
+		IGpAllocator *alloc = m_alloc;
 		this->~GpBWCursor_Win32();
-		free(this);
+		alloc->Release(this);
 	}
 }

Aerofoil/GpBWCursor_Win32.h

@@ -3,6 +3,8 @@
 #include "IGpCursor_Win32.h"
 #include "GpWindows.h"
 
+struct IGpAllocator;
+
 class GpBWCursor_Win32 final : public IGpCursor_Win32
 {
 public:
@@ -13,12 +15,13 @@ public:
 	void IncRef() override;
 	void DecRef() override;
 
-	static IGpCursor_Win32 *Create(size_t width, size_t height, const void *pixelData, const void *maskData, size_t hotSpotX, size_t hotSpotY);
+	static IGpCursor_Win32 *Create(IGpAllocator *alloc, size_t width, size_t height, const void *pixelData, const void *maskData, size_t hotSpotX, size_t hotSpotY);
 
 private:
-	GpBWCursor_Win32(HCURSOR cursor);
+	GpBWCursor_Win32(HCURSOR cursor, IGpAllocator *alloc);
 	~GpBWCursor_Win32();
 
 	HCURSOR m_cursor;
 	int m_refCount;
+	IGpAllocator *m_alloc;
 };

Aerofoil/GpColorCursor_Win32.cpp

@@ -20,6 +20,7 @@
 */
 
 #include "GpColorCursor_Win32.h"
+#include "IGpAllocator.h"
 
 #include <stdint.h>
 #include <stdlib.h>
@@ -31,7 +32,7 @@ void GpColorCursor_Win32::Destroy()
 	this->DecRef();
 }
 
-IGpCursor_Win32 *GpColorCursor_Win32::Create(size_t width, size_t height, const void *pixelDataRGBA, size_t hotSpotX, size_t hotSpotY)
+IGpCursor_Win32 *GpColorCursor_Win32::Create(IGpAllocator *alloc, size_t width, size_t height, const void *pixelDataRGBA, size_t hotSpotX, size_t hotSpotY)
 {
 	const size_t paddingBits = (sizeof(void*) * 8);
 
@@ -52,7 +53,7 @@ IGpCursor_Win32 *GpColorCursor_Win32::Create(size_t width, size_t height, const
 	size_t maskPitch = width + paddingBits - 1;
 	maskPitch -= maskPitch % paddingBits;
 
-	LPVOID maskBits = malloc(maskPitch * height);
+	LPVOID maskBits = alloc->Alloc(maskPitch * height);
 	if (!maskBits)
 		return nullptr;
 
@@ -71,6 +72,8 @@ IGpCursor_Win32 *GpColorCursor_Win32::Create(size_t width, size_t height, const
 	ii.hbmMask = CreateBitmap(width, height, 1, 1, maskBits);
 	ReleaseDC(NULL, hdc);
 
+	alloc->Release(maskBits);
+
 	size_t cursorPitch = width * 4;
 
 	size_t numPixels = width * height;
@@ -90,19 +93,20 @@ IGpCursor_Win32 *GpColorCursor_Win32::Create(size_t width, size_t height, const
 	if (!hicon)
 		return nullptr;
 
-	void *storage = malloc(sizeof(GpColorCursor_Win32));
+	void *storage = alloc->Alloc(sizeof(GpColorCursor_Win32));
 	if (!storage)
 	{
 		DestroyIcon(hicon);
 		return nullptr;
 	}
 
-	return new (storage) GpColorCursor_Win32(reinterpret_cast<HCURSOR>(hicon));
+	return new (storage) GpColorCursor_Win32(alloc, reinterpret_cast<HCURSOR>(hicon));
 }
 
-GpColorCursor_Win32::GpColorCursor_Win32(HCURSOR cursor)
+GpColorCursor_Win32::GpColorCursor_Win32(IGpAllocator *alloc, HCURSOR cursor)
 	: m_cursor(cursor)
 	, m_refCount(1)
+	, m_alloc(alloc)
 {
 }
 
@@ -126,7 +130,8 @@ void GpColorCursor_Win32::DecRef()
 	m_refCount--;
 	if (m_refCount == 0)
 	{
+		IGpAllocator *alloc = m_alloc;
 		this->~GpColorCursor_Win32();
-		free(this);
+		alloc->Release(this);
 	}
 }

Aerofoil/GpColorCursor_Win32.h

@@ -3,6 +3,7 @@
 #include "IGpCursor_Win32.h"
 #include "GpWindows.h"
 
+struct IGpAllocator;
 
 class GpColorCursor_Win32 final : public IGpCursor_Win32
 {
@@ -14,12 +15,13 @@ public:
 	void IncRef() override;
 	void DecRef() override;
 
-	static IGpCursor_Win32 *Create(size_t width, size_t height, const void *pixelDataRGBA, size_t hotSpotX, size_t hotSpotY);
+	static IGpCursor_Win32 *Create(IGpAllocator *alloc, size_t width, size_t height, const void *pixelDataRGBA, size_t hotSpotX, size_t hotSpotY);
 
 private:
-	GpColorCursor_Win32(HCURSOR cursor);
+	GpColorCursor_Win32(IGpAllocator *alloc, HCURSOR cursor);
 	~GpColorCursor_Win32();
 
 	HCURSOR m_cursor;
 	int m_refCount;
+	IGpAllocator *m_alloc;
 };

Aerofoil/GpFiberStarter_Win32.cpp

@@ -1,56 +0,0 @@
-#include "GpFiberStarter.h"
-#include "GpFiber_Win32.h"
-#include "GpWindows.h"
-
-#include <assert.h>
-
-namespace GpFiberStarter_Win32
-{
-	struct FiberStartState
-	{
-		GpFiberStarter::ThreadFunc_t m_threadFunc;
-		IGpFiber *m_creatingFiber;
-		void *m_context;
-	};
-
-	static VOID WINAPI FiberStartRoutine(LPVOID lpThreadParameter)
-	{
-		const FiberStartState *tss = static_cast<const FiberStartState*>(lpThreadParameter);
-
-		GpFiberStarter::ThreadFunc_t threadFunc = tss->m_threadFunc;
-		IGpFiber *creatingFiber = tss->m_creatingFiber;
-		void *context = tss->m_context;
-		SwitchToFiber(static_cast<GpFiber_Win32*>(creatingFiber)->GetFiber());
-
-		threadFunc(context);
-
-		assert(!"Fiber function exited");
-	}
-}
-
-IGpFiber *GpFiberStarter::StartFiber(PortabilityLayer::HostSystemServices *systemServices, ThreadFunc_t threadFunc, void *context, IGpFiber *creatingFiber)
-{
-	ULONG_PTR lowLimit;
-	ULONG_PTR highLimit;
-
-#if 0
-	GetCurrentThreadStackLimits(&lowLimit, &highLimit);
-
-	ULONG_PTR stackSize = highLimit - lowLimit;
-#else
-	ULONG_PTR stackSize = 1024 * 1024;
-#endif
-
-	GpFiberStarter_Win32::FiberStartState startState;
-	startState.m_context = context;
-	startState.m_creatingFiber = creatingFiber;
-	startState.m_threadFunc = threadFunc;
-
-	void *fiber = CreateFiber(static_cast<SIZE_T>(stackSize), GpFiberStarter_Win32::FiberStartRoutine, &startState);
-	if (!fiber)
-		return nullptr;
-
-	SwitchToFiber(fiber);
-
-	return GpFiber_Win32::Create(fiber);
-}

Aerofoil/GpFiber_Win32.cpp

@@ -1,37 +0,0 @@
-#include "GpFiber_Win32.h"
-#include <new>
-
-GpFiber_Win32::GpFiber_Win32(LPVOID fiber)
-	: m_fiber(fiber)
-{
-}
-
-void GpFiber_Win32::YieldTo(IGpFiber *toFiber)
-{
-	SwitchToFiber(static_cast<GpFiber_Win32*>(toFiber)->m_fiber);
-}
-
-void GpFiber_Win32::YieldToTerminal(IGpFiber *toFiber)
-{
-	YieldTo(toFiber);
-}
-
-void GpFiber_Win32::Destroy()
-{
-	this->~GpFiber_Win32();
-	free(this);
-}
-
-GpFiber_Win32::~GpFiber_Win32()
-{
-	DeleteFiber(m_fiber);
-}
-
-IGpFiber *GpFiber_Win32::Create(LPVOID fiber)
-{
-	void *storage = malloc(sizeof(GpFiber_Win32));
-	if (!storage)
-		return nullptr;
-
-	return new (storage) GpFiber_Win32(fiber);
-}

Aerofoil/GpFiber_Win32.h

@@ -1,26 +0,0 @@
-#pragma once
-#include "GpWindows.h"
-#include "IGpFiber.h"
-
-class GpFiber_Win32 final : public IGpFiber
-{
-public:
-	void YieldTo(IGpFiber *toFiber) override;
-	void YieldToTerminal(IGpFiber *toFiber) override;
-	void Destroy() override;
-
-	static IGpFiber *Create(LPVOID fiber);
-
-	LPVOID GetFiber() const;
-
-private:
-	explicit GpFiber_Win32(LPVOID fiber);
-	~GpFiber_Win32();
-
-	LPVOID m_fiber;
-};
-
-inline LPVOID GpFiber_Win32::GetFiber() const
-{
-	return m_fiber;
-}

Aerofoil/GpFileStream_Win32.cpp

@@ -1,13 +1,32 @@
 #include "GpFileStream_Win32.h"
+#include "IGpAllocator.h"
 
-GpFileStream_Win32::GpFileStream_Win32(HANDLE handle, bool readable, bool writeable, bool seekable)
-	: m_handle(handle)
+#include <new>
+
+GpFileStream_Win32::GpFileStream_Win32(IGpAllocator *alloc, HANDLE handle, bool readable, bool writeable, bool seekable)
+	: m_alloc(alloc)
+	, m_handle(handle)
 	, m_readable(readable)
 	, m_writeable(writeable)
 	, m_seekable(seekable)
 {
 }
 
+GpFileStream_Win32 *GpFileStream_Win32::Create(IGpAllocator *alloc, HANDLE handle, bool readable, bool writeable, bool seekable)
+{
+	void *storage = alloc->Alloc(sizeof(GpFileStream_Win32));
+	if (!storage)
+		return nullptr;
+
+	return new (storage) GpFileStream_Win32(alloc, handle, readable, writeable, seekable);
+}
+
+
+GpFileStream_Win32::~GpFileStream_Win32()
+{
+	CloseHandle(m_handle);
+}
+
 size_t GpFileStream_Win32::Read(void *bytesOut, size_t size)
 {
 	if (!m_readable)
@@ -99,24 +118,6 @@ bool GpFileStream_Win32::SeekEnd(GpUFilePos_t loc)
 	return SetFilePointerEx(m_handle, li, nullptr, FILE_END) != 0;
 }
 
-bool GpFileStream_Win32::Truncate(GpUFilePos_t loc)
-{
-	if (!m_writeable)
-		return false;
-
-	GpUFilePos_t oldPos = Tell();
-	if (!SeekStart(loc))
-		return false;
-
-	if (!SetEndOfFile(m_handle))
-		return false;
-
-	if (!SeekStart(oldPos))
-		return false;
-
-	return true;
-}
-
 GpUFilePos_t GpFileStream_Win32::Size() const
 {
 	LARGE_INTEGER fsize;
@@ -140,7 +141,10 @@ GpUFilePos_t GpFileStream_Win32::Tell() const
 
 void GpFileStream_Win32::Close()
 {
-	CloseHandle(m_handle);
+	IGpAllocator *alloc = m_alloc;
+	this->~GpFileStream_Win32();
+
+	alloc->Release(this);
 }
 
 void GpFileStream_Win32::Flush()

Aerofoil/GpFileStream_Win32.h

@@ -7,7 +7,7 @@
 class GpFileStream_Win32 final : public GpIOStream
 {
 public:
-	explicit GpFileStream_Win32(HANDLE handle, bool readable, bool writeable, bool seekable);
+	~GpFileStream_Win32();
 
 	size_t Read(void *bytesOut, size_t size) override;
 	size_t Write(const void *bytes, size_t size) override;
@@ -17,13 +17,21 @@ public:
 	bool SeekStart(GpUFilePos_t loc) override;
 	bool SeekCurrent(GpFilePos_t loc) override;
 	bool SeekEnd(GpUFilePos_t loc) override;
-	bool Truncate(GpUFilePos_t loc) override;
 	GpUFilePos_t Size() const override;
 	GpUFilePos_t Tell() const override;
-	void Close() override;
+	void GP_ASYNCIFY_PARANOID_NAMED(Close)() override;
 	void Flush() override;
 
+#if GP_ASYNCIFY_PARANOID
+	void Close();
+#endif
+
+	static GpFileStream_Win32 *Create(IGpAllocator *alloc, HANDLE handle, bool readable, bool writeable, bool seekable);
+
 private:
+	GpFileStream_Win32(IGpAllocator *alloc, HANDLE handle, bool readable, bool writeable, bool seekable);
+
+	IGpAllocator *m_alloc;
 	HANDLE m_handle;
 	bool m_readable;
 	bool m_writeable;

Aerofoil/GpFileSystem_Win32.cpp

@@ -1,45 +1,49 @@
 #include "GpFileSystem_Win32.h"
 
+#include "GpAllocator_C.h"
 #include "GpApplicationName.h"
 #include "GpFileStream_Win32.h"
 #include "GpWindows.h"
-#include "GpMemoryBuffer.h"
-#include "HostDirectoryCursor.h"
+#include "IGpAllocator.h"
+#include "IGpDirectoryCursor.h"
+
 
-#include <string>
 #include <Shlwapi.h>
 #include <ShlObj.h>
 #include <commdlg.h>
 
 #include <assert.h>
 
+struct IGpAllocator;
+
 extern GpWindowsGlobals g_gpWindowsGlobals;
 
-class GpDirectoryCursor_Win32 final : public PortabilityLayer::HostDirectoryCursor
+class GpDirectoryCursor_Win32 final : public IGpDirectoryCursor
 {
 public:
-	static GpDirectoryCursor_Win32 *Create(const HANDLE &handle, const WIN32_FIND_DATAW &findData);
+	static GpDirectoryCursor_Win32 *Create(IGpAllocator *alloc, const HANDLE &handle, const WIN32_FIND_DATAW &findData);
 
 	bool GetNext(const char *&outFileName) override;
 	void Destroy() override;
 
 private:
-	GpDirectoryCursor_Win32(const HANDLE &handle, const WIN32_FIND_DATAW &findData);
+	GpDirectoryCursor_Win32(IGpAllocator *alloc, const HANDLE &handle, const WIN32_FIND_DATAW &findData);
 	~GpDirectoryCursor_Win32();
 
+	IGpAllocator *m_alloc;
 	HANDLE m_handle;
 	WIN32_FIND_DATAW m_findData;
 	char m_chars[MAX_PATH + 1];
 	bool m_haveNext;
 };
 
-GpDirectoryCursor_Win32 *GpDirectoryCursor_Win32::Create(const HANDLE &handle, const WIN32_FIND_DATAW &findData)
+GpDirectoryCursor_Win32 *GpDirectoryCursor_Win32::Create(IGpAllocator *alloc, const HANDLE &handle, const WIN32_FIND_DATAW &findData)
 {
-	void *storage = malloc(sizeof(GpDirectoryCursor_Win32));
+	void *storage = alloc->Alloc(sizeof(GpDirectoryCursor_Win32));
 	if (!storage)
 		return nullptr;
 
-	return new (storage) GpDirectoryCursor_Win32(handle, findData);
+	return new (storage) GpDirectoryCursor_Win32(alloc, handle, findData);
 }
 
 bool GpDirectoryCursor_Win32::GetNext(const char *&outFileName)
@@ -83,14 +87,16 @@ bool GpDirectoryCursor_Win32::GetNext(const char *&outFileName)
 
 void GpDirectoryCursor_Win32::Destroy()
 {
+	IGpAllocator *alloc = m_alloc;
 	this->~GpDirectoryCursor_Win32();
-	free(this);
+	alloc->Release(this);
 }
 
-GpDirectoryCursor_Win32::GpDirectoryCursor_Win32(const HANDLE &handle, const WIN32_FIND_DATAW &findData)
+GpDirectoryCursor_Win32::GpDirectoryCursor_Win32(IGpAllocator *alloc, const HANDLE &handle, const WIN32_FIND_DATAW &findData)
 	: m_handle(handle)
 	, m_findData(findData)
 	, m_haveNext(true)
+	, m_alloc(alloc)
 {
 }
 
@@ -99,47 +105,76 @@ GpDirectoryCursor_Win32::~GpDirectoryCursor_Win32()
 	FindClose(m_handle);
 }
 
-GpFileSystem_Win32::GpFileSystem_Win32()
+GpFileSystem_Win32::GpFileSystem_Win32(IGpAllocator *alloc)
+	: m_alloc(alloc)
+	, m_prefsDir(alloc)
+	, m_scoresDir(alloc)
+	, m_packagedDir(alloc)
+	, m_housesDir(alloc)
+	, m_logsDir(alloc)
+	, m_userHousesDir(alloc)
+	, m_userSavesDir(alloc)
+	, m_resourcesDir(alloc)
+	, m_exportDir(alloc)
 {
-	// GP TODO: This shouldn't be static init since it allocates memory
 	m_executablePath[0] = 0;
+}
 
+void GpFileSystem_Win32::Destroy()
+{
+	IGpAllocator *alloc = m_alloc;
+	this->~GpFileSystem_Win32();
+	alloc->Release(this);
+}
+
+bool GpFileSystem_Win32::Init()
+{
 	PWSTR docsPath;
-	if (!FAILED(SHGetKnownFolderPath(FOLDERID_Documents, KF_FLAG_DEFAULT, nullptr, &docsPath)))
+	if (FAILED(SHGetKnownFolderPath(FOLDERID_Documents, KF_FLAG_DEFAULT, nullptr, &docsPath)))
+		return false;
+
+	if (!m_prefsDir.Set(docsPath))
 	{
-		try
-		{
-			m_prefsDir = docsPath;
-		}
-		catch(...)
-		{
-			CoTaskMemFree(docsPath);
-			throw;
-		}
-
-		m_prefsDir.append(L"\\" GP_APPLICATION_NAME_W);
-
-		m_userHousesDir = m_prefsDir + L"\\Houses";
-		m_userSavesDir = m_prefsDir + L"\\SavedGames";
-		m_scoresDir = m_prefsDir + L"\\Scores";
-		m_logsDir = m_prefsDir + L"\\Logs";
-		m_fontCacheDir = m_prefsDir + L"\\FontCache";
-
-		CreateDirectoryW(m_prefsDir.c_str(), nullptr);
-		CreateDirectoryW(m_scoresDir.c_str(), nullptr);
-		CreateDirectoryW(m_userHousesDir.c_str(), nullptr);
-		CreateDirectoryW(m_userSavesDir.c_str(), nullptr);
-		CreateDirectoryW(m_logsDir.c_str(), nullptr);
-		CreateDirectoryW(m_fontCacheDir.c_str(), nullptr);
-
-		m_prefsDir.append(L"\\");
-		m_scoresDir.append(L"\\");
-		m_userHousesDir.append(L"\\");
-		m_userSavesDir.append(L"\\");
-		m_logsDir.append(L"\\");
-		m_fontCacheDir.append(L"\\");
+		CoTaskMemFree(docsPath);
+		return false;
 	}
 
+	CoTaskMemFree(docsPath);
+
+	if (!m_prefsDir.Append(L"\\" GP_APPLICATION_NAME_W))
+		return false;
+
+	if (!m_userHousesDir.Set(m_prefsDir) || !m_userHousesDir.Append(L"\\Houses"))
+		return false;
+
+	if (!m_userSavesDir.Set(m_prefsDir) || !m_userSavesDir.Append(L"\\SavedGames"))
+		return false;
+
+	if (!m_scoresDir.Set(m_prefsDir) || !m_scoresDir.Append(L"\\Scores"))
+		return false;
+
+	if (!m_logsDir.Set(m_prefsDir) || !m_logsDir.Append(L"\\Logs"))
+		return false;
+
+	if (!m_exportDir.Set(m_prefsDir) || !m_exportDir.Append(L"\\Export"))
+		return false;
+
+	CreateDirectoryW(m_prefsDir.Buffer(), nullptr);
+	CreateDirectoryW(m_scoresDir.Buffer(), nullptr);
+	CreateDirectoryW(m_userHousesDir.Buffer(), nullptr);
+	CreateDirectoryW(m_userSavesDir.Buffer(), nullptr);
+	CreateDirectoryW(m_logsDir.Buffer(), nullptr);
+	CreateDirectoryW(m_exportDir.Buffer(), nullptr);
+
+	if (!m_prefsDir.Append(L"\\") ||
+		!m_scoresDir.Append(L"\\") ||
+		!m_userHousesDir.Append(L"\\") ||
+		!m_userSavesDir.Append(L"\\") ||
+		!m_logsDir.Append(L"\\") ||
+		!m_resourcesDir.Append(L"\\") ||
+		!m_exportDir.Append(L"\\"))
+		return false;
+
 	DWORD modulePathSize = GetModuleFileNameW(nullptr, m_executablePath, MAX_PATH);
 	if (modulePathSize == MAX_PATH || modulePathSize == 0)
 		m_executablePath[0] = 0;
@@ -159,7 +194,7 @@ GpFileSystem_Win32::GpFileSystem_Win32()
 			continue;
 		}
 
-		if (wcscat_s(m_executablePath, L"Resources"))
+		if (wcscat_s(m_executablePath, L"Packaged"))
 		{
 			currentPathLength = 0;
 			break;
@@ -174,12 +209,19 @@ GpFileSystem_Win32::GpFileSystem_Win32()
 			currentPathLength--;
 	}
 
-	if (currentPathLength > 0)
-	{
-		m_packagedDir = std::wstring(m_executablePath) + L"Packaged\\";
-		m_housesDir = std::wstring(m_executablePath) + L"Packaged\\Houses\\";
-		m_resourcesDir = std::wstring(m_executablePath) + L"Resources\\";
-	}
+	if (currentPathLength == 0)
+		return false;
+
+	if (!m_packagedDir.Set(m_executablePath) || !m_packagedDir.Append(L"Packaged\\"))
+		return false;
+
+	if (!m_housesDir.Set(m_executablePath) || !m_housesDir.Append(L"Packaged\\Houses\\"))
+		return false;
+
+	if (!m_resourcesDir.Set(m_executablePath) || !m_resourcesDir.Append(L"Resources\\"))
+		return false;
+
+	return true;
 }
 
 bool GpFileSystem_Win32::FileExists(PortabilityLayer::VirtualDirectory_t virtualDirectory, const char *path)
@@ -192,24 +234,24 @@ bool GpFileSystem_Win32::FileExists(PortabilityLayer::VirtualDirectory_t virtual
 	return PathFileExistsW(winPath) != 0;
 }
 
-bool GpFileSystem_Win32::FileLocked(PortabilityLayer::VirtualDirectory_t virtualDirectory, const char *path, bool *exists)
+bool GpFileSystem_Win32::FileLocked(PortabilityLayer::VirtualDirectory_t virtualDirectory, const char *path, bool &exists)
 {
 	wchar_t winPath[MAX_PATH + 1];
 
 	if (!ResolvePath(virtualDirectory, &path, 1, winPath))
 	{
-		*exists = false;
+		exists = false;
 		return false;
 	}
 
 	DWORD attribs = GetFileAttributesW(winPath);
 	if (attribs == INVALID_FILE_ATTRIBUTES)
 	{
-		*exists = false;
+		exists = false;
 		return false;
 	}
 
-	*exists = true;
+	exists = true;
 	return (attribs & FILE_ATTRIBUTE_READONLY) != 0;
 }
 
@@ -248,7 +290,7 @@ GpIOStream *GpFileSystem_Win32::OpenFileNested(PortabilityLayer::VirtualDirector
 	if (h == INVALID_HANDLE_VALUE)
 		return false;
 
-	return new GpFileStream_Win32(h, true, writeAccess, true);
+	return GpFileStream_Win32::Create(m_alloc, h, true, writeAccess, true);
 }
 
 bool GpFileSystem_Win32::DeleteFile(PortabilityLayer::VirtualDirectory_t virtualDirectory, const char *path, bool &existed)
@@ -273,11 +315,11 @@ bool GpFileSystem_Win32::DeleteFile(PortabilityLayer::VirtualDirectory_t virtual
 	return false;
 }
 
-PortabilityLayer::HostDirectoryCursor *GpFileSystem_Win32::ScanDirectoryNested(PortabilityLayer::VirtualDirectory_t virtualDirectory, char const* const* paths, size_t numPaths)
+IGpDirectoryCursor *GpFileSystem_Win32::ScanDirectoryNested(PortabilityLayer::VirtualDirectory_t virtualDirectory, char const* const* paths, size_t numPaths)
 {
 	wchar_t winPath[MAX_PATH + 2];
 
-	const char **expandedPaths = static_cast<const char**>(malloc(sizeof(const char*) * (numPaths + 1)));
+	const char **expandedPaths = static_cast<const char**>(m_alloc->Alloc(sizeof(const char*) * (numPaths + 1)));
 	if (!expandedPaths)
 		return nullptr;
 
@@ -286,7 +328,7 @@ PortabilityLayer::HostDirectoryCursor *GpFileSystem_Win32::ScanDirectoryNested(P
 	expandedPaths[numPaths] = "*";
 
 	const bool isPathResolved = ResolvePath(virtualDirectory, expandedPaths, numPaths + 1, winPath);
-	free(expandedPaths);
+	m_alloc->Release(expandedPaths);
 
 	if (!isPathResolved)
 		return nullptr;
@@ -297,7 +339,7 @@ PortabilityLayer::HostDirectoryCursor *GpFileSystem_Win32::ScanDirectoryNested(P
 	if (ff == INVALID_HANDLE_VALUE)
 		return nullptr;
 
-	return GpDirectoryCursor_Win32::Create(ff, findData);
+	return GpDirectoryCursor_Win32::Create(m_alloc, ff, findData);
 }
 
 bool GpFileSystem_Win32::ValidateFilePathUnicodeChar(uint32_t c) const
@@ -320,16 +362,6 @@ bool GpFileSystem_Win32::ValidateFilePathUnicodeChar(uint32_t c) const
 	return false;
 }
 
-bool GpFileSystem_Win32::IsVirtualDirectoryLooseResources(PortabilityLayer::VirtualDirectory_t virtualDir) const
-{
-	return false;
-}
-
-void GpFileSystem_Win32::SetMainThreadRelay(IGpThreadRelay *relay)
-{
-	(void)relay;
-}
-
 void GpFileSystem_Win32::SetDelayCallback(GpFileSystem_Win32::DelayCallback_t delayCallback)
 {
 }
@@ -342,7 +374,7 @@ bool GpFileSystem_Win32::ValidateFilePath(const char *str, size_t length) const
 		if (c >= '0' && c <= '9')
 			continue;
 
-		if (c == '_' || c == '.' || c == '\'')
+		if (c == '_' || c == '.' || c == '\'' || c == '!')
 			continue;
 
 		if (c == ' ' && i != 0 && i != length - 1)
@@ -430,9 +462,27 @@ const wchar_t *GpFileSystem_Win32::GetBasePath() const
 	return m_executablePath;
 }
 
+GpFileSystem_Win32 *GpFileSystem_Win32::CreateInstance(IGpAllocator *alloc)
+{
+	void *storage = alloc->Alloc(sizeof(GpFileSystem_Win32));
+	if (!storage)
+		return nullptr;
+
+	GpFileSystem_Win32 *fs = new (storage) GpFileSystem_Win32(alloc);
+	if (!fs->Init())
+	{
+		fs->Destroy();
+		return nullptr;
+	}
+
+	ms_instance = fs;
+
+	return fs;
+}
+
 GpFileSystem_Win32 *GpFileSystem_Win32::GetInstance()
 {
-	return &ms_instance;
+	return ms_instance;
 }
 
 bool GpFileSystem_Win32::ResolvePath(PortabilityLayer::VirtualDirectory_t virtualDirectory, char const* const* paths, size_t numPaths, wchar_t *outPath)
@@ -442,31 +492,31 @@ bool GpFileSystem_Win32::ResolvePath(PortabilityLayer::VirtualDirectory_t virtua
 	switch (virtualDirectory)
 	{
 	case PortabilityLayer::VirtualDirectories::kApplicationData:
-		baseDir = m_packagedDir.c_str();
+		baseDir = m_packagedDir.Buffer();
 		break;
 	case PortabilityLayer::VirtualDirectories::kGameData:
-		baseDir = m_housesDir.c_str();
+		baseDir = m_housesDir.Buffer();
 		break;
 	case PortabilityLayer::VirtualDirectories::kUserData:
-		baseDir = m_userHousesDir.c_str();
+		baseDir = m_userHousesDir.Buffer();
 		break;
 	case PortabilityLayer::VirtualDirectories::kUserSaves:
-		baseDir = m_userSavesDir.c_str();
+		baseDir = m_userSavesDir.Buffer();
 		break;
 	case PortabilityLayer::VirtualDirectories::kPrefs:
-		baseDir = m_prefsDir.c_str();
+		baseDir = m_prefsDir.Buffer();
 		break;
 	case PortabilityLayer::VirtualDirectories::kFonts:
-		baseDir = m_resourcesDir.c_str();
+		baseDir = m_resourcesDir.Buffer();
 		break;
 	case PortabilityLayer::VirtualDirectories::kHighScores:
-		baseDir = m_scoresDir.c_str();
+		baseDir = m_scoresDir.Buffer();
 		break;
 	case PortabilityLayer::VirtualDirectories::kLogs:
-		baseDir = m_logsDir.c_str();
+		baseDir = m_logsDir.Buffer();
 		break;
-	case PortabilityLayer::VirtualDirectories::kFontCache:
-		baseDir = m_fontCacheDir.c_str();
+	case PortabilityLayer::VirtualDirectories::kSourceExport:
+		baseDir = m_exportDir.Buffer();
 		break;
 	default:
 		return false;
@@ -512,4 +562,4 @@ bool GpFileSystem_Win32::ResolvePath(PortabilityLayer::VirtualDirectory_t virtua
 	return true;
 }
 
-GpFileSystem_Win32 GpFileSystem_Win32::ms_instance;
+GpFileSystem_Win32 *GpFileSystem_Win32::ms_instance;

Aerofoil/GpFileSystem_Win32.h

@@ -1,48 +1,51 @@
 #pragma once
 
-#include "HostFileSystem.h"
+#include "IGpFileSystem.h"
 
 #include "GpCoreDefs.h"
 #include "GpWindows.h"
+#include "GpString.h"
 
-#include <string>
-
-class GpFileSystem_Win32 final : public PortabilityLayer::HostFileSystem
+class GpFileSystem_Win32 final : public IGpFileSystem
 {
 public:
-	GpFileSystem_Win32();
+	explicit GpFileSystem_Win32(IGpAllocator *alloc);
+
+	void Destroy();
 
 	bool FileExists(PortabilityLayer::VirtualDirectory_t virtualDirectory, const char *path) override;
-	bool FileLocked(PortabilityLayer::VirtualDirectory_t virtualDirectory, const char *path, bool *exists) override;
+	bool FileLocked(PortabilityLayer::VirtualDirectory_t virtualDirectory, const char *path, bool &exists) override;
 	GpIOStream *OpenFileNested(PortabilityLayer::VirtualDirectory_t virtualDirectory, char const* const* paths, size_t numPaths, bool writeAccess, GpFileCreationDisposition_t createDisposition) override;
 	bool DeleteFile(PortabilityLayer::VirtualDirectory_t virtualDirectory, const char *path, bool &existed) override;
-	PortabilityLayer::HostDirectoryCursor *ScanDirectoryNested(PortabilityLayer::VirtualDirectory_t virtualDirectory, char const* const* paths, size_t numPaths) override;
+	IGpDirectoryCursor *ScanDirectoryNested(PortabilityLayer::VirtualDirectory_t virtualDirectory, char const* const* paths, size_t numPaths) override;
 
 	bool ValidateFilePath(const char *path, size_t sz) const override;
 	bool ValidateFilePathUnicodeChar(uint32_t ch) const override;
 
-	bool IsVirtualDirectoryLooseResources(PortabilityLayer::VirtualDirectory_t virtualDir) const override;
-
-	void SetMainThreadRelay(IGpThreadRelay *relay) override;
 	void SetDelayCallback(DelayCallback_t delayCallback) override;
 
 	const wchar_t *GetBasePath() const;
 
+	static GpFileSystem_Win32 *CreateInstance(IGpAllocator *alloc);
 	static GpFileSystem_Win32 *GetInstance();
 
 private:
+	bool Init();
+
 	bool ResolvePath(PortabilityLayer::VirtualDirectory_t virtualDirectory, char const* const* paths, size_t numPaths, wchar_t *outPath);
 
-	std::wstring m_prefsDir;
-	std::wstring m_scoresDir;
-	std::wstring m_packagedDir;
-	std::wstring m_housesDir;
-	std::wstring m_logsDir;
-	std::wstring m_userHousesDir;
-	std::wstring m_userSavesDir;
-	std::wstring m_resourcesDir;
-	std::wstring m_fontCacheDir;
+	GpWString m_prefsDir;
+	GpWString m_scoresDir;
+	GpWString m_packagedDir;
+	GpWString m_housesDir;
+	GpWString m_logsDir;
+	GpWString m_userHousesDir;
+	GpWString m_userSavesDir;
+	GpWString m_resourcesDir;
+	GpWString m_exportDir;
 	wchar_t m_executablePath[MAX_PATH];
 
-	static GpFileSystem_Win32 ms_instance;
+	IGpAllocator *m_alloc;
+
+	static GpFileSystem_Win32 *ms_instance;
 };

Aerofoil/GpLogDriver_Win32.cpp

@@ -1,3 +1,4 @@
+#include "GpAllocator_C.h"
 #include "GpLogDriver_Win32.h"
 #include "GpFileSystem_Win32.h"
 
@@ -7,6 +8,7 @@
 GpLogDriver_Win32::GpLogDriver_Win32()
 	: m_stream(nullptr)
 	, m_isInitialized(false)
+	, m_alloc(GpAllocator_C::GetInstance())
 {
 }
 
@@ -58,14 +60,14 @@ void GpLogDriver_Win32::VPrintf(Category category, const char *fmt, va_list args
 		if (formattedSize <= 0)
 			return;
 
-		char *charBuff = static_cast<char*>(malloc(formattedSize + 1));
+		char *charBuff = static_cast<char*>(m_alloc->Alloc(formattedSize + 1));
 		if (!charBuff)
 			return;
 
 		vsnprintf(charBuff, formattedSize + 1, fmt, args);
 
 		m_stream->Write(charBuff, formattedSize);
-		free(charBuff);
+		m_alloc->Release(charBuff);
 	}
 
 	m_stream->Write("\n", 1);

Aerofoil/GpLogDriver_Win32.h

@@ -3,6 +3,7 @@
 #include "IGpLogDriver.h"
 
 class GpIOStream;
+struct IGpAllocator;
 
 class GpLogDriver_Win32 : public IGpLogDriver
 {
@@ -20,6 +21,7 @@ private:
 	void InitInternal();
 
 	GpIOStream *m_stream;
+	IGpAllocator *m_alloc;
 	bool m_isInitialized;
 
 	static GpLogDriver_Win32 ms_instance;

Aerofoil/GpMain_Win32.cpp

@@ -1,10 +1,10 @@
 #include "GpMain.h"
+#include "GpAllocator_C.h"
 #include "GpAudioDriverFactory.h"
 #include "GpBWCursor_Win32.h"
 #include "GpColorCursor_Win32.h"
 #include "GpDisplayDriverFactory.h"
 #include "GpGlobalConfig.h"
-#include "GpFiber_Win32.h"
 #include "GpFileSystem_Win32.h"
 #include "GpLogDriver_Win32.h"
 #include "GpFontHandlerFactory.h"
@@ -12,10 +12,9 @@
 #include "GpAppInterface.h"
 #include "GpSystemServices_Win32.h"
 #include "GpVOSEvent.h"
+#include "IGpFileSystem.h"
 #include "IGpVOSEventQueue.h"
 
-#include "HostFileSystem.h"
-
 #include "GpWindows.h"
 
 #include "resource.h"
@@ -29,7 +28,6 @@ GpWindowsGlobals g_gpWindowsGlobals;
 extern "C" __declspec(dllimport) IGpAudioDriver *GpDriver_CreateAudioDriver_XAudio2(const GpAudioDriverProperties &properties);
 extern "C" __declspec(dllimport) IGpDisplayDriver *GpDriver_CreateDisplayDriver_D3D11(const GpDisplayDriverProperties &properties);
 extern "C" __declspec(dllimport) IGpInputDriver *GpDriver_CreateInputDriver_XInput(const GpInputDriverProperties &properties);
-extern "C" __declspec(dllimport) IGpFontHandler *GpDriver_CreateFontHandler_FreeType2(const GpFontHandlerProperties &properties);
 
 static void PostMouseEvent(IGpVOSEventQueue *eventQueue, GpMouseEventType_t eventType, GpMouseButton_t button, int32_t x, int32_t y, float pixelScaleX, float pixelScaleY)
 {
@@ -406,6 +404,13 @@ int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine
 	int nArgs;
 	LPWSTR *cmdLineArgs = CommandLineToArgvW(cmdLine, &nArgs);
 
+	IGpAllocator *alloc = GpAllocator_C::GetInstance();
+
+	// Init file system first since logging may depend on it
+	GpFileSystem_Win32 *fs = GpFileSystem_Win32::CreateInstance(alloc);
+	if (!fs)
+		return -1;
+
 	for (int i = 1; i < nArgs; i++)
 	{
 		if (!wcscmp(cmdLineArgs[i], L"-diagnostics"))
@@ -413,10 +418,14 @@ int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine
 	}
 
 	IGpLogDriver *logger = GpLogDriver_Win32::GetInstance();
+	IGpSystemServices *sysServices = GpSystemServices_Win32::GetInstance();
 
-	GpAppInterface_Get()->PL_HostFileSystem_SetInstance(GpFileSystem_Win32::GetInstance());
-	GpAppInterface_Get()->PL_HostSystemServices_SetInstance(GpSystemServices_Win32::GetInstance());
-	GpAppInterface_Get()->PL_HostLogDriver_SetInstance(GpLogDriver_Win32::GetInstance());
+	GpDriverCollection *drivers = GpAppInterface_Get()->PL_GetDriverCollection();
+
+	drivers->SetDriver<GpDriverIDs::kFileSystem>(GpFileSystem_Win32::GetInstance());
+	drivers->SetDriver<GpDriverIDs::kSystemServices>(sysServices);
+	drivers->SetDriver<GpDriverIDs::kLog>(logger);
+	drivers->SetDriver<GpDriverIDs::kAlloc>(alloc);
 
 	g_gpWindowsGlobals.m_hInstance = hInstance;
 	g_gpWindowsGlobals.m_hPrevInstance = hPrevInstance;
@@ -429,7 +438,6 @@ int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine
 	g_gpWindowsGlobals.m_hIcon = LoadIconW(hInstance, MAKEINTRESOURCEW(IDI_ICON1));
 	g_gpWindowsGlobals.m_hIconSm = LoadIconW(hInstance, MAKEINTRESOURCEW(IDI_ICON2));
 
-	g_gpWindowsGlobals.m_createFiberFunc = GpFiber_Win32::Create;
 	g_gpWindowsGlobals.m_createBWCursorFunc = GpBWCursor_Win32::Create;
 	g_gpWindowsGlobals.m_createColorCursorFunc = GpColorCursor_Win32::Create;
 	g_gpWindowsGlobals.m_translateWindowsMessageFunc = TranslateWindowsMessage;
@@ -438,7 +446,7 @@ int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine
 
 	g_gpGlobalConfig.m_audioDriverType = EGpAudioDriverType_XAudio2;
 
-	g_gpGlobalConfig.m_fontHandlerType = EGpFontHandlerType_FreeType2;
+	g_gpGlobalConfig.m_fontHandlerType = EGpFontHandlerType_None;
 
 	EGpInputDriverType inputDrivers[] =
 	{
@@ -450,12 +458,12 @@ int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine
 
 	g_gpGlobalConfig.m_osGlobals = &g_gpWindowsGlobals;
 	g_gpGlobalConfig.m_logger = logger;
-	g_gpGlobalConfig.m_systemServices = GpSystemServices_Win32::GetInstance();
+	g_gpGlobalConfig.m_systemServices = sysServices;
+	g_gpGlobalConfig.m_allocator = alloc;
 
 	GpDisplayDriverFactory::RegisterDisplayDriverFactory(EGpDisplayDriverType_D3D11, GpDriver_CreateDisplayDriver_D3D11);
 	GpAudioDriverFactory::RegisterAudioDriverFactory(EGpAudioDriverType_XAudio2, GpDriver_CreateAudioDriver_XAudio2);
 	GpInputDriverFactory::RegisterInputDriverFactory(EGpInputDriverType_XInput, GpDriver_CreateInputDriver_XInput);
-	GpFontHandlerFactory::RegisterFontHandlerFactory(EGpFontHandlerType_FreeType2, GpDriver_CreateFontHandler_FreeType2);
 
 	if (logger)
 		logger->Printf(IGpLogDriver::Category_Information, "Windows environment configured, starting up");
@@ -467,5 +475,7 @@ int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine
 
 	LocalFree(cmdLineArgs);
 
+	fs->Destroy();
+
 	return returnCode;
 }

Aerofoil/GpMutex_Win32.cpp

@@ -1,5 +1,6 @@
 #include "GpMutex_Win32.h"
 
+#include "IGpAllocator.h"
 #include "GpWindows.h"
 
 #include <stdlib.h>
@@ -7,8 +8,9 @@
 
 void GpMutex_Win32::Destroy()
 {
+	IGpAllocator *alloc = m_alloc;
 	this->~GpMutex_Win32();
-	free(this);
+	alloc->Release(this);
 }
 
 void GpMutex_Win32::Lock()
@@ -22,16 +24,17 @@ void GpMutex_Win32::Unlock()
 }
 
 
-GpMutex_Win32 *GpMutex_Win32::Create()
+GpMutex_Win32 *GpMutex_Win32::Create(IGpAllocator *alloc)
 {
-	void *storage = malloc(sizeof(GpMutex_Win32));
+	void *storage = alloc->Alloc(sizeof(GpMutex_Win32));
 	if (!storage)
 		return nullptr;
 
-	return new (storage) GpMutex_Win32();
+	return new (storage) GpMutex_Win32(alloc);
 }
 
-GpMutex_Win32::GpMutex_Win32()
+GpMutex_Win32::GpMutex_Win32(IGpAllocator *alloc)
+	: m_alloc(alloc)
 {
 	InitializeCriticalSection(&m_critSection);
 }

Aerofoil/GpMutex_Win32.h

@@ -1,21 +1,24 @@
 #pragma once
 
-#include "HostMutex.h"
+#include "IGpMutex.h"
 
 #include "GpWindows.h"
 
-class GpMutex_Win32 final : public PortabilityLayer::HostMutex
+struct IGpAllocator;
+
+class GpMutex_Win32 final : public IGpMutex
 {
 public:
 	void Destroy() override;
 	void Lock() override;
 	void Unlock() override;
 
-	static GpMutex_Win32 *Create();
+	static GpMutex_Win32 *Create(IGpAllocator *alloc);
 
 private:
-	const GpMutex_Win32();
+	explicit GpMutex_Win32(IGpAllocator *alloc);
 	~GpMutex_Win32();
 
 	CRITICAL_SECTION m_critSection;
+	IGpAllocator *m_alloc;
 };

Aerofoil/GpSystemServices_Win32.cpp

@@ -1,19 +1,122 @@
 #include "GpSystemServices_Win32.h"
 #include "GpMutex_Win32.h"
 #include "GpThreadEvent_Win32.h"
+#include "GpWindows.h"
+#include "GpAllocator_C.h"
+
+#include "IGpClipboardContents.h"
+
+#include "GpUnicode.h"
 
 #include <assert.h>
+#include <vector>
 
 #pragma push_macro("CreateMutex")
 #ifdef CreateMutex
 #undef CreateMutex
 #endif
 
+extern GpWindowsGlobals g_gpWindowsGlobals;
+
+namespace GpSystemServices_Win32_Private
+{
+	class RefCountedClipboard
+	{
+	public:
+		RefCountedClipboard();
+
+	protected:
+		virtual ~RefCountedClipboard();
+
+		void AddRef();
+		void DecRef();
+
+		unsigned int m_refCount;
+	};
+
+	class TextClipboard : public RefCountedClipboard, public IGpClipboardContentsText
+	{
+	public:
+		TextClipboard(const uint8_t *utf8Text, size_t utf8Size);
+		~TextClipboard() override;
+
+		GpClipboardContentsType_t GetContentsType() const override;
+		void Destroy() override;
+		IGpClipboardContents *Clone() const override;
+		const uint8_t *GetBytes() const override;
+		size_t GetSize() const override;
+
+	private:
+		std::vector<uint8_t> m_utf8Text;
+	};
+
+
+	RefCountedClipboard::RefCountedClipboard()
+		: m_refCount(1)
+	{
+	}
+
+	RefCountedClipboard::~RefCountedClipboard()
+	{
+	}
+
+	void RefCountedClipboard::AddRef()
+	{
+		m_refCount++;
+	}
+
+	void RefCountedClipboard::DecRef()
+	{
+		unsigned int rc = --m_refCount;
+		if (rc == 0)
+			delete this;
+	}
+
+	TextClipboard::TextClipboard(const uint8_t *utf8Text, size_t utf8Size)
+	{
+		m_utf8Text.resize(utf8Size);
+		if (utf8Size > 0)
+			memcpy(&m_utf8Text[0], utf8Text, utf8Size);
+	}
+
+	TextClipboard::~TextClipboard()
+	{
+	}
+
+	GpClipboardContentsType_t TextClipboard::GetContentsType() const
+	{
+		return GpClipboardContentsTypes::kText;
+	}
+
+	void TextClipboard::Destroy()
+	{
+		this->DecRef();
+	}
+
+	IGpClipboardContents *TextClipboard::Clone() const
+	{
+		const_cast<TextClipboard*>(this)->AddRef();
+		return const_cast<TextClipboard*>(this);
+	}
+
+	const uint8_t *TextClipboard::GetBytes() const
+	{
+		if (m_utf8Text.size() == 0)
+			return nullptr;
+		return &m_utf8Text[0];
+	}
+
+	size_t TextClipboard::GetSize() const
+	{
+		return m_utf8Text.size();
+	}
+}
+
 struct GpSystemServices_Win32_ThreadStartParams
 {
 	GpSystemServices_Win32::ThreadFunc_t m_threadFunc;
 	void *m_threadContext;
-	PortabilityLayer::HostThreadEvent *m_threadStartEvent;
+	IGpThreadEvent *m_threadStartEvent;
 };
 
 static DWORD WINAPI StaticStartThread(LPVOID lpThreadParameter)
@@ -22,7 +125,7 @@ static DWORD WINAPI StaticStartThread(LPVOID lpThreadParameter)
 
 	GpSystemServices_Win32::ThreadFunc_t threadFunc = threadParams->m_threadFunc;
 	void *threadContext = threadParams->m_threadContext;
-	PortabilityLayer::HostThreadEvent *threadStartEvent = threadParams->m_threadStartEvent;
+	IGpThreadEvent *threadStartEvent = threadParams->m_threadStartEvent;
 
 	threadStartEvent->Signal();
 
@@ -31,6 +134,11 @@ static DWORD WINAPI StaticStartThread(LPVOID lpThreadParameter)
 
 GpSystemServices_Win32::GpSystemServices_Win32()
 	: m_isTouchscreenSimulation(false)
+	, m_alloc(GpAllocator_C::GetInstance())
+{
+}
+
+GpSystemServices_Win32::~GpSystemServices_Win32()
 {
 }
 
@@ -72,24 +180,24 @@ void GpSystemServices_Win32::GetLocalDateTime(unsigned int &year, unsigned int &
 	second = localTime.wSecond;
 }
 
-PortabilityLayer::HostMutex *GpSystemServices_Win32::CreateMutex()
+IGpMutex *GpSystemServices_Win32::CreateMutex()
 {
-	return GpMutex_Win32::Create();
+	return GpMutex_Win32::Create(m_alloc);
 }
 
-PortabilityLayer::HostMutex *GpSystemServices_Win32::CreateRecursiveMutex()
+IGpMutex *GpSystemServices_Win32::CreateRecursiveMutex()
 {
-	return GpMutex_Win32::Create();
+	return GpMutex_Win32::Create(m_alloc);
 }
 
-PortabilityLayer::HostThreadEvent *GpSystemServices_Win32::CreateThreadEvent(bool autoReset, bool startSignaled)
+IGpThreadEvent *GpSystemServices_Win32::CreateThreadEvent(bool autoReset, bool startSignaled)
 {
-	return GpThreadEvent_Win32::Create(autoReset, startSignaled);
+	return GpThreadEvent_Win32::Create(m_alloc, autoReset, startSignaled);
 }
 
 void *GpSystemServices_Win32::CreateThread(ThreadFunc_t threadFunc, void *context)
 {
-	PortabilityLayer::HostThreadEvent *evt = CreateThreadEvent(true, false);
+	IGpThreadEvent *evt = CreateThreadEvent(true, false);
 	if (!evt)
 		return nullptr;
 
@@ -124,9 +232,10 @@ uint64_t GpSystemServices_Win32::GetFreeMemoryCosmetic() const
 	return memStatus.ullAvailPhys;
 }
 
-void GpSystemServices_Win32::Beep() const
+bool GpSystemServices_Win32::Beep() const
 {
 	MessageBeep(MB_OK);
+	return true;
 }
 
 bool GpSystemServices_Win32::IsTouchscreen() const
@@ -144,6 +253,31 @@ bool GpSystemServices_Win32::IsTextInputObstructive() const
 	return false;
 }
 
+bool GpSystemServices_Win32::IsFullscreenPreferred() const
+{
+	return !m_isTouchscreenSimulation;
+}
+
+bool GpSystemServices_Win32::IsFullscreenOnStartup() const
+{
+	return false;
+}
+
+bool GpSystemServices_Win32::HasNativeFileManager() const
+{
+	return true;
+}
+
+GpOperatingSystem_t GpSystemServices_Win32::GetOperatingSystem() const
+{
+	return GpOperatingSystems::kWindows;
+}
+
+GpOperatingSystemFlavor_t GpSystemServices_Win32::GetOperatingSystemFlavor() const
+{
+	return GpOperatingSystemFlavors::kGeneric;
+}
+
 unsigned int GpSystemServices_Win32::GetCPUCount() const
 {
 	SYSTEM_INFO sysInfo;
@@ -161,6 +295,95 @@ bool GpSystemServices_Win32::IsTextInputEnabled() const
 	return true;
 }
 
+bool GpSystemServices_Win32::AreFontResourcesSeekable() const
+{
+	return true;
+}
+
+IGpClipboardContents *GpSystemServices_Win32::GetClipboardContents() const
+{
+	IGpClipboardContents *cbObject = nullptr;
+
+	if (IsClipboardFormatAvailable(CF_UNICODETEXT))
+	{
+		if (OpenClipboard(g_gpWindowsGlobals.m_hwnd))
+		{
+			HGLOBAL textHandle = GetClipboardData(CF_UNICODETEXT);
+			if (textHandle)
+			{
+				const wchar_t *str = static_cast<const wchar_t*>(GlobalLock(textHandle));
+				if (str)
+				{
+					if (str[0] == 0)
+						cbObject = new GpSystemServices_Win32_Private::TextClipboard(nullptr, 0);
+					else
+					{
+						int bytesRequired = WideCharToMultiByte(CP_UTF8, 0, str, -1, nullptr, 0, nullptr, nullptr);
+
+						if (bytesRequired > 0)
+						{
+							std::vector<char> decodedText;
+							decodedText.resize(bytesRequired);
+							WideCharToMultiByte(CP_UTF8, 0, str, -1, &decodedText[0], bytesRequired, nullptr, nullptr);
+
+							cbObject = new GpSystemServices_Win32_Private::TextClipboard(reinterpret_cast<const uint8_t*>(&decodedText[0]), decodedText.size() - 1);
+						}
+					}
+
+					GlobalUnlock(textHandle);
+				}
+			}
+			CloseClipboard();
+		}
+	}
+
+	return cbObject;
+}
+
+void GpSystemServices_Win32::SetClipboardContents(IGpClipboardContents *contents)
+{
+	if (!contents)
+		return;
+
+	if (contents->GetContentsType() == GpClipboardContentsTypes::kText)
+	{
+		IGpClipboardContentsText *textContents = static_cast<IGpClipboardContentsText*>(contents);
+
+		if (OpenClipboard(g_gpWindowsGlobals.m_hwnd))
+		{
+			if (EmptyClipboard())
+			{
+				int wcharsRequired = MultiByteToWideChar(CP_UTF8, 0, reinterpret_cast<const char*>(textContents->GetBytes()), textContents->GetSize(), nullptr, 0);
+
+				std::vector<wchar_t> wideChars;
+
+				if (wcharsRequired)
+				{
+					wideChars.resize(wcharsRequired + 1);
+					MultiByteToWideChar(CP_UTF8, 0, reinterpret_cast<const char*>(textContents->GetBytes()), textContents->GetSize(), &wideChars[0], wcharsRequired);
+				}
+				else
+					wideChars.resize(1);
+
+				wideChars[wideChars.size() - 1] = static_cast<wchar_t>(0);
+
+				HGLOBAL textObject = GlobalAlloc(GMEM_MOVEABLE, wideChars.size() * sizeof(wchar_t));
+				if (textObject)
+				{
+					wchar_t *buffer = static_cast<wchar_t*>(GlobalLock(textObject));
+					memcpy(buffer, &wideChars[0], wideChars.size() * sizeof(wchar_t));
+					GlobalUnlock(textObject);
+
+					SetClipboardData(CF_UNICODETEXT, textObject);
+				}
+			}
+
+			CloseClipboard();
+		}
+	}
+}
+
+
 void GpSystemServices_Win32::SetTouchscreenSimulation(bool isTouchscreenSimulation)
 {
 	m_isTouchscreenSimulation = isTouchscreenSimulation;

Aerofoil/GpSystemServices_Win32.h

@@ -1,6 +1,6 @@
 #pragma once
 
-#include "HostSystemServices.h"
+#include "IGpSystemServices.h"
 #include "GpCoreDefs.h"
 #include "GpWindows.h"
 
@@ -15,25 +15,34 @@
 #endif
 
 
-class GpSystemServices_Win32 final : public PortabilityLayer::HostSystemServices
+class GpSystemServices_Win32 final : public IGpSystemServices
 {
 public:
 	GpSystemServices_Win32();
+	~GpSystemServices_Win32();
 
 	int64_t GetTime() const override;
 	void GetLocalDateTime(unsigned int &year, unsigned int &month, unsigned int &day, unsigned int &hour, unsigned int &minute, unsigned int &second) const override;
-	PortabilityLayer::HostMutex *CreateMutex() override;
-	PortabilityLayer::HostMutex *CreateRecursiveMutex() override;
+	IGpMutex *CreateMutex() override;
+	IGpMutex *CreateRecursiveMutex() override;
 	void *CreateThread(ThreadFunc_t threadFunc, void *context) override;
-	PortabilityLayer::HostThreadEvent *CreateThreadEvent(bool autoReset, bool startSignaled) override;
+	IGpThreadEvent *CreateThreadEvent(bool autoReset, bool startSignaled) override;
 	uint64_t GetFreeMemoryCosmetic() const override;
-	void Beep() const override;
+	bool Beep() const override;
 	bool IsTouchscreen() const override;
 	bool IsUsingMouseAsTouch() const override;
 	bool IsTextInputObstructive() const override;
+	bool IsFullscreenPreferred() const override;
+	bool IsFullscreenOnStartup() const override;
+	bool HasNativeFileManager() const override;
+	GpOperatingSystem_t GetOperatingSystem() const override;
+	GpOperatingSystemFlavor_t GetOperatingSystemFlavor() const override;
 	unsigned int GetCPUCount() const override;
 	void SetTextInputEnabled(bool isEnabled) override;
 	bool IsTextInputEnabled() const override;
+	bool AreFontResourcesSeekable() const override;
+	IGpClipboardContents *GetClipboardContents() const override;
+	void SetClipboardContents(IGpClipboardContents *contents) override;
 
 	void SetTouchscreenSimulation(bool isTouchscreenSimulation);
 
@@ -42,6 +51,8 @@ public:
 private:
 	bool m_isTouchscreenSimulation;
 
+	IGpAllocator *m_alloc;
+
 	static GpSystemServices_Win32 ms_instance;
 };
 

Aerofoil/GpThreadEvent_Win32.cpp

@@ -1,4 +1,5 @@
 #include "GpThreadEvent_Win32.h"
+#include "IGpAllocator.h"
 
 #include <stdlib.h>
 #include <new>
@@ -20,28 +21,30 @@ void GpThreadEvent_Win32::Signal()
 
 void GpThreadEvent_Win32::Destroy()
 {
+	IGpAllocator *alloc = m_alloc;
 	this->~GpThreadEvent_Win32();
-	free(this);
+	alloc->Release(this);
 }
 
-GpThreadEvent_Win32 *GpThreadEvent_Win32::Create(bool autoReset, bool startSignaled)
+GpThreadEvent_Win32 *GpThreadEvent_Win32::Create(IGpAllocator *alloc, bool autoReset, bool startSignaled)
 {
 	HANDLE handle = CreateEventA(nullptr, autoReset ? FALSE : TRUE, startSignaled ? TRUE : FALSE, nullptr);
 	if (handle == nullptr)
 		return nullptr;
 
-	void *storage = malloc(sizeof(GpThreadEvent_Win32));
+	void *storage = alloc->Alloc(sizeof(GpThreadEvent_Win32));
 	if (!storage)
 	{
 		CloseHandle(handle);
 		return nullptr;
 	}
 
-	return new (storage) GpThreadEvent_Win32(handle);
+	return new (storage) GpThreadEvent_Win32(alloc, handle);
 }
 
-GpThreadEvent_Win32::GpThreadEvent_Win32(const HANDLE &handle)
+GpThreadEvent_Win32::GpThreadEvent_Win32(IGpAllocator *alloc, const HANDLE &handle)
 	: m_event(handle)
+	, m_alloc(alloc)
 {
 }
 

Aerofoil/GpThreadEvent_Win32.h

@@ -1,10 +1,10 @@
 #pragma once
 
-#include "HostThreadEvent.h"
+#include "IGpThreadEvent.h"
 
 #include "GpWindows.h"
 
-class GpThreadEvent_Win32 final : public PortabilityLayer::HostThreadEvent
+class GpThreadEvent_Win32 final : public IGpThreadEvent
 {
 public:
 	void Wait() override;
@@ -12,11 +12,12 @@ public:
 	void Signal() override;
 	void Destroy() override;
 
-	static GpThreadEvent_Win32 *Create(bool autoReset, bool startSignaled);
+	static GpThreadEvent_Win32 *Create(IGpAllocator *alloc, bool autoReset, bool startSignaled);
 
 private:
-	explicit GpThreadEvent_Win32(const HANDLE &handle);
+	explicit GpThreadEvent_Win32(IGpAllocator *alloc, const HANDLE &handle);
 	~GpThreadEvent_Win32();
 
 	HANDLE m_event;
+	IGpAllocator *m_alloc;
 };

AerofoilAndroid/app/build.gradle

@@ -15,8 +15,8 @@ android {
         }
         minSdkVersion 16
         targetSdkVersion 29
-        versionCode 3
-        versionName "1.0.9b1"
+        versionCode 15
+        versionName "1.1.1"
         externalNativeBuild {
             ndkBuild {
                 arguments "APP_PLATFORM=android-16"
@@ -66,7 +66,7 @@ android {
     }
 
 	aaptOptions {
-		noCompress 'gpa'
+		noCompress 'gpf'
 	}
 }
 

AerofoilAndroid/app/jni/.gitignore

@@ -1,4 +1,5 @@
 AerofoilSDL
+AerofoilPortable
 Common
 FreeType
 GpApp

AerofoilAndroid/app/jni/main/Android.mk

@@ -9,6 +9,7 @@ SDL_PATH := ../SDL
 LOCAL_C_INCLUDES := $(LOCAL_PATH)/$(SDL_PATH)/include	\
 	$(LOCAL_PATH)/../GpShell	\
 	$(LOCAL_PATH)/../GpCommon	\
+	$(LOCAL_PATH)/../AerofoilPortable	\
 	$(LOCAL_PATH)/../AerofoilSDL	\
 	$(LOCAL_PATH)/../Common	\
 	$(LOCAL_PATH)/../PortabilityLayer
@@ -23,7 +24,7 @@ LOCAL_SRC_FILES := \
 
 LOCAL_SHARED_LIBRARIES := SDL2
 
-LOCAL_STATIC_LIBRARIES := GpShell GpFontHandler_FreeType2 AerofoilSDL GpApp
+LOCAL_STATIC_LIBRARIES := GpShell AerofoilPortable AerofoilSDL GpApp
 
 LOCAL_LDLIBS := -lGLESv1_CM -lGLESv2 -llog
 

AerofoilAndroid/app/jni/main/GpFileSystem_Android.cpp

@@ -1,12 +1,14 @@
 #define _LARGEFILE64_SOURCE
 #include "GpFileSystem_Android.h"
 #include "GpIOStream.h"
-#include "HostDirectoryCursor.h"
-#include "HostSystemServices.h"
-#include "HostMutex.h"
+#include "IGpDirectoryCursor.h"
+#include "IGpSystemServices.h"
+#include "IGpMutex.h"
 #include "IGpThreadRelay.h"
 #include "VirtualDirectory.h"
 
+#include "PLDrivers.h"
+
 #include "SDL.h"
 #include "SDL_rwops.h"
 
@@ -40,7 +42,6 @@ public:
 	bool SeekStart(GpUFilePos_t loc) override;
 	bool SeekCurrent(GpFilePos_t loc) override;
 	bool SeekEnd(GpUFilePos_t loc) override;
-	bool Truncate(GpUFilePos_t loc) override;
 	GpUFilePos_t Size() const override;
 	GpUFilePos_t Tell() const override;
 	void Close() override;
@@ -68,7 +69,6 @@ public:
 	bool SeekStart(GpUFilePos_t loc) override;
 	bool SeekCurrent(GpFilePos_t loc) override;
 	bool SeekEnd(GpUFilePos_t loc) override;
-	bool Truncate(GpUFilePos_t loc) override;
 	GpUFilePos_t Size() const override;
 	GpUFilePos_t Tell() const override;
 	void Close() override;
@@ -94,7 +94,6 @@ public:
 	bool SeekStart(GpUFilePos_t loc) override;
 	bool SeekCurrent(GpFilePos_t loc) override;
 	bool SeekEnd(GpUFilePos_t loc) override;
-	bool Truncate(GpUFilePos_t loc) override;
 	GpUFilePos_t Size() const override;
 	GpUFilePos_t Tell() const override;
 	void Close() override;
@@ -166,11 +165,6 @@ bool GpFileStream_PFD::SeekEnd(GpUFilePos_t loc)
 	return lseek64(m_fd, loc, SEEK_END) >= 0;
 }
 
-bool GpFileStream_PFD::Truncate(GpUFilePos_t loc)
-{
-	return ftruncate64(m_fd, static_cast<off64_t>(loc)) >= 0;
-}
-
 GpUFilePos_t GpFileStream_PFD::Size() const
 {
 	struct stat64 s;
@@ -249,11 +243,6 @@ bool GpFileStream_SDLRWops::SeekEnd(GpUFilePos_t loc)
 	return m_rw->seek(m_rw, -static_cast<Sint64>(loc), RW_SEEK_END) >= 0;
 }
 
-bool GpFileStream_SDLRWops::Truncate(GpUFilePos_t loc)
-{
-	return false;
-}
-
 GpUFilePos_t GpFileStream_SDLRWops::Size() const
 {
 	return m_rw->size(m_rw);
@@ -344,12 +333,6 @@ bool GpFileStream_Android_File::SeekEnd(GpUFilePos_t loc)
 	return lseek64(m_fd, -static_cast<off64_t>(loc), SEEK_END) >= 0;
 }
 
-bool GpFileStream_Android_File::Truncate(GpUFilePos_t loc)
-{
-	fflush(m_f);
-	return ftruncate64(m_fd, static_cast<off64_t>(loc)) >= 0;
-}
-
 GpUFilePos_t GpFileStream_Android_File::Size() const
 {
 	fflush(m_f);
@@ -380,7 +363,7 @@ void GpFileStream_Android_File::Flush()
 bool GpFileSystem_Android::OpenSourceExportFD(PortabilityLayer::VirtualDirectory_t virtualDirectory, const char *const *paths, size_t numPaths, int &fd, jobject &pfd)
 {
 	if (!m_sourceExportMutex)
-		m_sourceExportMutex = PortabilityLayer::HostSystemServices::GetInstance()->CreateMutex();
+		m_sourceExportMutex = PLDrivers::GetSystemServices()->CreateMutex();
 
 	m_sourceExportWaiting = true;
 	m_sourceExportCancelled = false;
@@ -441,9 +424,6 @@ bool GpFileSystem_Android::ResolvePath(PortabilityLayer::VirtualDirectory_t virt
 	case PortabilityLayer::VirtualDirectories::kPrefs:
 		prefsAppend = "Prefs";
 		break;
-	case PortabilityLayer::VirtualDirectories::kFontCache:
-		prefsAppend = "FontCache";
-		break;
 	default:
 		return false;
 	};
@@ -467,7 +447,6 @@ bool GpFileSystem_Android::ResolvePath(PortabilityLayer::VirtualDirectory_t virt
 
 GpFileSystem_Android::GpFileSystem_Android()
 	: m_activity(nullptr)
-	, m_relay(nullptr)
 	, m_delayCallback(nullptr)
 	, m_sourceExportMutex(nullptr)
 	, m_sourceExportFD(0)
@@ -550,26 +529,26 @@ bool GpFileSystem_Android::FileExists(PortabilityLayer::VirtualDirectory_t virtu
 	return stat(resolvedPath.c_str(), &s) == 0;
 }
 
-bool GpFileSystem_Android::FileLocked(PortabilityLayer::VirtualDirectory_t virtualDirectory, const char *path, bool *exists)
+bool GpFileSystem_Android::FileLocked(PortabilityLayer::VirtualDirectory_t virtualDirectory, const char *path, bool &exists)
 {
 	std::string resolvedPath;
 	bool isAsset;
 	if (!ResolvePath(virtualDirectory, &path, 1, resolvedPath, isAsset))
 	{
 		if (exists)
-			*exists = false;
+			exists = false;
 		return false;
 	}
 
 	if (isAsset)
 	{
 		if (exists)
-			*exists = this->FileExists(virtualDirectory, path);
+			exists = this->FileExists(virtualDirectory, path);
 		return true;
 	}
 
 	int permissions = access(resolvedPath.c_str(), W_OK | F_OK);
-	*exists = ((permissions & F_OK) != 0);
+	exists = ((permissions & F_OK) != 0);
 	return ((permissions & W_OK) != 0);
 }
 
@@ -696,26 +675,7 @@ bool GpFileSystem_Android::DeleteFile(PortabilityLayer::VirtualDirectory_t virtu
 	return true;
 }
 
-PortabilityLayer::HostDirectoryCursor *GpFileSystem_Android::ScanDirectoryNested(PortabilityLayer::VirtualDirectory_t virtualDirectory, const char *const *paths, size_t numPaths)
-{
-	ScanDirectoryNestedContext ctx;
-	ctx.m_this = this;
-	ctx.m_returnValue = nullptr;
-	ctx.m_virtualDirectory = virtualDirectory;
-	ctx.m_paths = paths;
-	ctx.m_numPaths = numPaths;
-	m_relay->Invoke(ScanDirectoryNestedThunk, &ctx);
-
-	return ctx.m_returnValue;
-}
-
-void GpFileSystem_Android::ScanDirectoryNestedThunk(void *context)
-{
-	ScanDirectoryNestedContext *ctx = static_cast<ScanDirectoryNestedContext*>(context);
-	ctx->m_returnValue = ctx->m_this->ScanDirectoryNestedInternal(ctx->m_virtualDirectory, ctx->m_paths, ctx->m_numPaths);
-}
-
-PortabilityLayer::HostDirectoryCursor *GpFileSystem_Android::ScanDirectoryNestedInternal(PortabilityLayer::VirtualDirectory_t virtualDirectory, const char *const *paths, size_t numPaths)
+IGpDirectoryCursor *GpFileSystem_Android::ScanDirectoryNested(PortabilityLayer::VirtualDirectory_t virtualDirectory, const char *const *paths, size_t numPaths)
 {
 	if (virtualDirectory == PortabilityLayer::VirtualDirectories::kGameData || virtualDirectory == PortabilityLayer::VirtualDirectories::kApplicationData)
 		return ScanAssetDirectory(virtualDirectory, paths, numPaths);
@@ -731,7 +691,7 @@ bool GpFileSystem_Android::ValidateFilePath(const char *path, size_t length) con
 		if (c >= '0' && c <= '9')
 			continue;
 
-		if (c == '_' || c == '.' || c == '\'')
+		if (c == '_' || c == '.' || c == '\'' || c == '!')
 			continue;
 
 		if (c == ' ' && i != 0 && i != length - 1)
@@ -769,16 +729,6 @@ bool GpFileSystem_Android::ValidateFilePathUnicodeChar(uint32_t c) const
 	return false;
 }
 
-bool GpFileSystem_Android::IsVirtualDirectoryLooseResources(PortabilityLayer::VirtualDirectory_t virtualDir) const
-{
-	return false;
-}
-
-void GpFileSystem_Android::SetMainThreadRelay(IGpThreadRelay *relay)
-{
-	m_relay = relay;
-}
-
 void GpFileSystem_Android::SetDelayCallback(DelayCallback_t delayCallback)
 {
 	m_delayCallback = delayCallback;
@@ -809,7 +759,7 @@ GpFileSystem_Android *GpFileSystem_Android::GetInstance()
 	return &ms_instance;
 }
 
-class GpDirectoryCursor_StringList final : public PortabilityLayer::HostDirectoryCursor
+class GpDirectoryCursor_StringList final : public IGpDirectoryCursor
 {
 public:
 	explicit GpDirectoryCursor_StringList(std::vector<std::string> &paths);
@@ -847,7 +797,7 @@ void GpDirectoryCursor_StringList::Destroy()
 	delete this;
 }
 
-class GpDirectoryCursor_POSIX final : public PortabilityLayer::HostDirectoryCursor
+class GpDirectoryCursor_POSIX final : public IGpDirectoryCursor
 {
 public:
 	explicit GpDirectoryCursor_POSIX(DIR *dir);
@@ -885,7 +835,7 @@ void GpDirectoryCursor_POSIX::Destroy()
 	delete this;
 }
 
-PortabilityLayer::HostDirectoryCursor *GpFileSystem_Android::ScanAssetDirectory(PortabilityLayer::VirtualDirectory_t virtualDirectory, char const* const* paths, size_t numPaths)
+IGpDirectoryCursor *GpFileSystem_Android::ScanAssetDirectory(PortabilityLayer::VirtualDirectory_t virtualDirectory, char const* const* paths, size_t numPaths)
 {
 
 	std::string resolvedPath;
@@ -919,7 +869,7 @@ PortabilityLayer::HostDirectoryCursor *GpFileSystem_Android::ScanAssetDirectory(
 	return new GpDirectoryCursor_StringList(subPaths);
 }
 
-PortabilityLayer::HostDirectoryCursor *GpFileSystem_Android::ScanStorageDirectory(PortabilityLayer::VirtualDirectory_t virtualDirectory, char const* const* paths, size_t numPaths)
+IGpDirectoryCursor *GpFileSystem_Android::ScanStorageDirectory(PortabilityLayer::VirtualDirectory_t virtualDirectory, char const* const* paths, size_t numPaths)
 {
 	std::string resolvedPath;
 	std::vector<std::string> subPaths;

AerofoilAndroid/app/jni/main/GpFileSystem_Android.h

@@ -1,18 +1,15 @@
 #pragma once
 
-#include "HostFileSystem.h"
+#include "IGpFileSystem.h"
 
 #include "GpCoreDefs.h"
 
 #include <jni.h>
 #include <string>
 
-namespace PortabilityLayer
-{
-	class HostMutex;
-}
+struct IGpMutex;
 
-class GpFileSystem_Android final : public PortabilityLayer::HostFileSystem
+class GpFileSystem_Android final : public IGpFileSystem
 {
 public:
 	GpFileSystem_Android();
@@ -22,17 +19,14 @@ public:
 	void ShutdownJNI();
 
 	bool FileExists(PortabilityLayer::VirtualDirectory_t virtualDirectory, const char *path) override;
-	bool FileLocked(PortabilityLayer::VirtualDirectory_t virtualDirectory, const char *path, bool *exists) override;
+	bool FileLocked(PortabilityLayer::VirtualDirectory_t virtualDirectory, const char *path, bool &exists) override;
 	GpIOStream *OpenFileNested(PortabilityLayer::VirtualDirectory_t virtualDirectory, char const* const* subPaths, size_t numSubPaths, bool writeAccess, GpFileCreationDisposition_t createDisposition) override;
 	bool DeleteFile(PortabilityLayer::VirtualDirectory_t virtualDirectory, const char *path, bool &existed) override;
-	PortabilityLayer::HostDirectoryCursor *ScanDirectoryNested(PortabilityLayer::VirtualDirectory_t virtualDirectory, char const* const* paths, size_t numPaths) override;
+	IGpDirectoryCursor *ScanDirectoryNested(PortabilityLayer::VirtualDirectory_t virtualDirectory, char const* const* paths, size_t numPaths) override;
 
 	bool ValidateFilePath(const char *path, size_t pathLen) const override;
 	bool ValidateFilePathUnicodeChar(uint32_t ch) const override;
 
-	bool IsVirtualDirectoryLooseResources(PortabilityLayer::VirtualDirectory_t virtualDir) const override;
-
-	void SetMainThreadRelay(IGpThreadRelay *relay) override;
 	void SetDelayCallback(DelayCallback_t delayCallback) override;
 
 	void PostSourceExportRequest(bool cancelled, int fd, jobject pfd);
@@ -41,26 +35,12 @@ public:
 	static GpFileSystem_Android *GetInstance();
 
 private:
-	struct ScanDirectoryNestedContext
-	{
-		GpFileSystem_Android *m_this;
-
-		PortabilityLayer::HostDirectoryCursor *m_returnValue;
-		PortabilityLayer::VirtualDirectory_t m_virtualDirectory;
-		char const *const *m_paths;
-		size_t m_numPaths;
-	};
-
-	static void ScanDirectoryNestedThunk(void *context);
-	PortabilityLayer::HostDirectoryCursor *ScanDirectoryNestedInternal(PortabilityLayer::VirtualDirectory_t virtualDirectory, char const* const* paths, size_t numPaths);
-
-	PortabilityLayer::HostDirectoryCursor *ScanAssetDirectory(PortabilityLayer::VirtualDirectory_t virtualDirectory, char const* const* paths, size_t numPaths);
-	PortabilityLayer::HostDirectoryCursor *ScanStorageDirectory(PortabilityLayer::VirtualDirectory_t virtualDirectory, char const* const* paths, size_t numPaths);
+	IGpDirectoryCursor *ScanAssetDirectory(PortabilityLayer::VirtualDirectory_t virtualDirectory, char const* const* paths, size_t numPaths);
+	IGpDirectoryCursor *ScanStorageDirectory(PortabilityLayer::VirtualDirectory_t virtualDirectory, char const* const* paths, size_t numPaths);
 
 	bool OpenSourceExportFD(PortabilityLayer::VirtualDirectory_t virtualDirectory, char const* const* paths, size_t numPaths, int &fd, jobject &pfd);
 	bool ResolvePath(PortabilityLayer::VirtualDirectory_t virtualDirectory, char const* const* paths, size_t numPaths, std::string &resolution, bool &isAsset);
 
-	IGpThreadRelay *m_relay;
 	DelayCallback_t m_delayCallback;
 
 	jobject m_activity;
@@ -68,7 +48,7 @@ private:
 	jmethodID m_selectSourceExportPathMID;
 	jmethodID m_closeSourceExportPFDMID;
 
-	PortabilityLayer::HostMutex *m_sourceExportMutex;
+	IGpMutex *m_sourceExportMutex;
 	int m_sourceExportFD;
 	bool m_sourceExportWaiting;
 	bool m_sourceExportCancelled;

AerofoilAndroid/app/jni/main/GpMain_SDL_Android.cpp

@@ -1,21 +1,22 @@
 #include "SDL.h"
 
 #include "GpMain.h"
+#include "GpAllocator_C.h"
 #include "GpAudioDriverFactory.h"
 #include "GpDisplayDriverFactory.h"
 #include "GpGlobalConfig.h"
-#include "GpFiber_SDL.h"
 #include "GpFileSystem_Android.h"
 #include "GpFontHandlerFactory.h"
 #include "GpInputDriverFactory.h"
+#include "GpInputDriver_SDL_Gamepad.h"
 #include "GpAppInterface.h"
 #include "GpSystemServices_Android.h"
 #include "GpVOSEvent.h"
 #include "IGpVOSEventQueue.h"
 #include "IGpLogDriver.h"
 
-#include "HostFileSystem.h"
-#include "HostThreadEvent.h"
+#include "IGpFileSystem.h"
+#include "IGpThreadEvent.h"
 
 #include "GpAndroid.h"
 
@@ -23,8 +24,6 @@
 
 GpAndroidGlobals g_gpAndroidGlobals;
 
-extern "C" IGpFontHandler *GpDriver_CreateFontHandler_FreeType2(const GpFontHandlerProperties &properties);
-
 IGpDisplayDriver *GpDriver_CreateDisplayDriver_SDL_GL2(const GpDisplayDriverProperties &properties);
 IGpAudioDriver *GpDriver_CreateAudioDriver_SDL(const GpAudioDriverProperties &properties);
 
@@ -72,6 +71,8 @@ GpLogDriver_Android GpLogDriver_Android::ms_instance;
 
 int main(int argc, char* argv[])
 {
+	IGpAllocator *alloc = GpAllocator_C::GetInstance();
+
 	SDL_LogSetAllPriority(SDL_LOG_PRIORITY_INFO);
 
 	if (SDL_Init(SDL_INIT_VIDEO) < 0)
@@ -81,15 +82,17 @@ int main(int argc, char* argv[])
 
 	GpFileSystem_Android::GetInstance()->InitJNI();
 
-	GpAppInterface_Get()->PL_HostFileSystem_SetInstance(GpFileSystem_Android::GetInstance());
-	GpAppInterface_Get()->PL_HostSystemServices_SetInstance(GpSystemServices_Android::GetInstance());
-	GpAppInterface_Get()->PL_HostLogDriver_SetInstance(GpLogDriver_Android::GetInstance());
+	GpDriverCollection *drivers = GpAppInterface_Get()->PL_GetDriverCollection();
+	drivers->SetDriver<GpDriverIDs::kFileSystem>(GpFileSystem_Android::GetInstance());
+	drivers->SetDriver<GpDriverIDs::kSystemServices>(GpSystemServices_Android::GetInstance());
+	drivers->SetDriver<GpDriverIDs::kLog>(GpLogDriver_Android::GetInstance());
+	drivers->SetDriver<GpDriverIDs::kAlloc>(alloc);
 
 	g_gpGlobalConfig.m_displayDriverType = EGpDisplayDriverType_SDL_GL2;
 
 	g_gpGlobalConfig.m_audioDriverType = EGpAudioDriverType_SDL2;
 
-	g_gpGlobalConfig.m_fontHandlerType = EGpFontHandlerType_FreeType2;
+	g_gpGlobalConfig.m_fontHandlerType = EGpFontHandlerType_None;
 
 	g_gpGlobalConfig.m_inputDriverTypes = nullptr;
 	g_gpGlobalConfig.m_numInputDrivers = 0;
@@ -97,10 +100,10 @@ int main(int argc, char* argv[])
 	g_gpGlobalConfig.m_osGlobals = &g_gpAndroidGlobals;
 	g_gpGlobalConfig.m_logger = GpLogDriver_Android::GetInstance();
 	g_gpGlobalConfig.m_systemServices = GpSystemServices_Android::GetInstance();
+	g_gpGlobalConfig.m_allocator = alloc;
 
 	GpDisplayDriverFactory::RegisterDisplayDriverFactory(EGpDisplayDriverType_SDL_GL2, GpDriver_CreateDisplayDriver_SDL_GL2);
 	GpAudioDriverFactory::RegisterAudioDriverFactory(EGpAudioDriverType_SDL2, GpDriver_CreateAudioDriver_SDL);
-	GpFontHandlerFactory::RegisterFontHandlerFactory(EGpFontHandlerType_FreeType2, GpDriver_CreateFontHandler_FreeType2);
 
 	int returnCode = GpMain::Run();
 
@@ -115,3 +118,8 @@ int main(int argc, char* argv[])
 
 	return returnCode;
 }
+
+IGpInputDriverSDLGamepad *IGpInputDriverSDLGamepad::GetInstance()
+{
+	return nullptr;
+}

AerofoilAndroid/app/jni/main/GpSystemServices_Android.cpp

@@ -1,18 +1,16 @@
 #include "GpSystemServices_Android.h"
-#include "HostMutex.h"
-#include "HostThreadEvent.h"
+
+#include "IGpThreadEvent.h"
 #include "SDL.h"
 
 #include <time.h>
-#include <mutex>
-#include <condition_variable>
 #include <unistd.h>
 
 struct GpSystemServices_Android_ThreadStartParams
 {
 	GpSystemServices_Android::ThreadFunc_t m_threadFunc;
 	void *m_threadContext;
-	PortabilityLayer::HostThreadEvent *m_threadStartEvent;
+	IGpThreadEvent *m_threadStartEvent;
 };
 
 static int SDLCALL StaticStartThread(void *lpThreadParameter)
@@ -21,185 +19,21 @@ static int SDLCALL StaticStartThread(void *lpThreadParameter)
 
 	GpSystemServices_Android::ThreadFunc_t threadFunc = threadParams->m_threadFunc;
 	void *threadContext = threadParams->m_threadContext;
-	PortabilityLayer::HostThreadEvent *threadStartEvent = threadParams->m_threadStartEvent;
+	IGpThreadEvent *threadStartEvent = threadParams->m_threadStartEvent;
 
 	threadStartEvent->Signal();
 
 	return threadFunc(threadContext);
 }
 
-template<class TMutex>
-class GpMutex_Cpp11 final : public PortabilityLayer::HostMutex
-{
-public:
-	GpMutex_Cpp11();
-	~GpMutex_Cpp11();
-
-	void Destroy() override;
-
-	void Lock() override;
-	void Unlock() override;
-
-private:
-	TMutex m_mutex;
-};
-
-template<class TMutex>
-GpMutex_Cpp11<TMutex>::GpMutex_Cpp11()
-{
-}
-
-template<class TMutex>
-GpMutex_Cpp11<TMutex>::~GpMutex_Cpp11()
-{
-}
-
-template<class TMutex>
-void GpMutex_Cpp11<TMutex>::Destroy()
-{
-	this->~GpMutex_Cpp11();
-	free(this);
-}
-
-template<class TMutex>
-void GpMutex_Cpp11<TMutex>::Lock()
-{
-	m_mutex.lock();
-}
-
-template<class TMutex>
-void GpMutex_Cpp11<TMutex>::Unlock()
-{
-	m_mutex.unlock();
-}
-
-typedef GpMutex_Cpp11<std::mutex> GpMutex_Cpp11_Vanilla;
-typedef GpMutex_Cpp11<std::recursive_mutex> GpMutex_Cpp11_Recursive;
-
-
-class GpThreadEvent_Cpp11 final : public PortabilityLayer::HostThreadEvent
-{
-public:
-	GpThreadEvent_Cpp11(bool autoReset, bool startSignaled);
-	~GpThreadEvent_Cpp11();
-
-	void Wait() override;
-	bool WaitTimed(uint32_t msec) override;
-	void Signal() override;
-	void Destroy() override;
-
-private:
-	std::mutex m_mutex;
-	std::condition_variable m_cvar;
-	bool m_flag;
-	bool m_autoReset;
-};
-
-GpThreadEvent_Cpp11::GpThreadEvent_Cpp11(bool autoReset, bool startSignaled)
-	: m_flag(startSignaled)
-	, m_autoReset(autoReset)
-{
-}
-
-GpThreadEvent_Cpp11::~GpThreadEvent_Cpp11()
-{
-}
-
-void GpThreadEvent_Cpp11::Wait()
-{
-	std::unique_lock<std::mutex> lock(m_mutex);
-	if (m_autoReset)
-	{
-		m_cvar.wait(lock,[&]()->bool{
-			if (m_flag)
-			{
-				m_flag = false;
-				return true;
-			}
-			else
-				return false;
-		});
-	}
-	else
-		m_cvar.wait(lock,[&]()->bool{ return m_flag; });
-}
-
-bool GpThreadEvent_Cpp11::WaitTimed(uint32_t msec)
-{
-	std::unique_lock<std::mutex> lock(m_mutex);
-	if (m_autoReset)
-	{
-		if (!m_cvar.wait_for(lock, std::chrono::milliseconds(msec), [&]()->bool{
-			if (m_flag)
-			{
-				m_flag = false;
-				return true;
-			}
-			else
-				return false;
-		}))
-			return false;
-	}
-	else
-	{
-		if (!m_cvar.wait_for(lock, std::chrono::milliseconds(msec), [&]()->bool{ return m_flag; }))
-			return false;
-	}
-	return true;
-}
-
-void GpThreadEvent_Cpp11::Signal()
-{
-	m_mutex.lock();
-	m_flag = true;
-	m_mutex.unlock();
-	if (m_autoReset)
-		m_cvar.notify_one();
-	else
-		m_cvar.notify_all();
-}
-
-void GpThreadEvent_Cpp11::Destroy()
-{
-	this->~GpThreadEvent_Cpp11();
-	free(this);
-}
-
 GpSystemServices_Android::GpSystemServices_Android()
 	: m_textInputEnabled(false)
 {
 }
 
-int64_t GpSystemServices_Android::GetTime() const
-{
-	time_t t = time(nullptr);
-	return static_cast<int64_t>(t) - 2082844800;
-}
-
-void GpSystemServices_Android::GetLocalDateTime(unsigned int &year, unsigned int &month, unsigned int &day, unsigned int &hour, unsigned int &minute, unsigned int &second) const
-{
-	time_t t = time(nullptr);
-	tm *tmObject = localtime(&t);
-	year = static_cast<unsigned int>(tmObject->tm_year);
-	month = static_cast<unsigned int>(tmObject->tm_mon + 1);
-	hour = static_cast<unsigned int>(tmObject->tm_hour);
-	minute = static_cast<unsigned int>(tmObject->tm_min);
-	second = static_cast<unsigned int>(tmObject->tm_sec);
-}
-
-PortabilityLayer::HostMutex *GpSystemServices_Android::CreateMutex()
-{
-	GpMutex_Cpp11_Vanilla *mutex = static_cast<GpMutex_Cpp11_Vanilla*>(malloc(sizeof(GpMutex_Cpp11_Vanilla)));
-	if (!mutex)
-		return nullptr;
-
-	return new (mutex) GpMutex_Cpp11_Vanilla();
-}
-
-
 void *GpSystemServices_Android::CreateThread(ThreadFunc_t threadFunc, void *context)
 {
-	PortabilityLayer::HostThreadEvent *evt = CreateThreadEvent(true, false);
+	IGpThreadEvent *evt = CreateThreadEvent(true, false);
 	if (!evt)
 		return nullptr;
 
@@ -221,33 +55,9 @@ void *GpSystemServices_Android::CreateThread(ThreadFunc_t threadFunc, void *cont
 	return thread;
 }
 
-PortabilityLayer::HostMutex *GpSystemServices_Android::CreateRecursiveMutex()
-{
-	GpMutex_Cpp11_Recursive *mutex = static_cast<GpMutex_Cpp11_Recursive*>(malloc(sizeof(GpMutex_Cpp11_Recursive)));
-	if (!mutex)
-		return nullptr;
-
-	return new (mutex) GpMutex_Cpp11_Recursive();
-}
-
-PortabilityLayer::HostThreadEvent *GpSystemServices_Android::CreateThreadEvent(bool autoReset, bool startSignaled)
-{
-	GpThreadEvent_Cpp11 *evt = static_cast<GpThreadEvent_Cpp11*>(malloc(sizeof(GpThreadEvent_Cpp11)));
-	if (!evt)
-		return nullptr;
-
-	return new (evt) GpThreadEvent_Cpp11(autoReset, startSignaled);
-}
-
-uint64_t GpSystemServices_Android::GetFreeMemoryCosmetic() const
-{
-	long pages = sysconf(_SC_AVPHYS_PAGES);
-	long pageSize = sysconf(_SC_PAGE_SIZE);
-	return pages * pageSize;
-}
-
-void GpSystemServices_Android::Beep() const
+bool GpSystemServices_Android::Beep() const
 {
+	return false;
 }
 
 bool GpSystemServices_Android::IsTouchscreen() const
@@ -265,6 +75,31 @@ bool GpSystemServices_Android::IsTextInputObstructive() const
 	return true;
 }
 
+bool GpSystemServices_Android::IsFullscreenPreferred() const
+{
+	return true;
+}
+
+bool GpSystemServices_Android::IsFullscreenOnStartup() const
+{
+	return true;
+}
+
+bool GpSystemServices_Android::HasNativeFileManager() const
+{
+	return false;
+}
+
+GpOperatingSystem_t GpSystemServices_Android::GetOperatingSystem() const
+{
+	return GpOperatingSystems::kAndroid;
+}
+
+GpOperatingSystemFlavor_t GpSystemServices_Android::GetOperatingSystemFlavor() const
+{
+	return GpOperatingSystemFlavors::kGeneric;
+}
+
 unsigned int GpSystemServices_Android::GetCPUCount() const
 {
 	return SDL_GetCPUCount();
@@ -280,6 +115,20 @@ bool GpSystemServices_Android::IsTextInputEnabled() const
 	return m_textInputEnabled;
 }
 
+bool GpSystemServices_Android::AreFontResourcesSeekable() const
+{
+	return false;
+}
+
+IGpClipboardContents *GpSystemServices_Android::GetClipboardContents() const
+{
+	return nullptr;
+}
+
+void GpSystemServices_Android::SetClipboardContents(IGpClipboardContents *contents)
+{
+}
+
 GpSystemServices_Android *GpSystemServices_Android::GetInstance()
 {
 	return &ms_instance;

AerofoilAndroid/app/jni/main/GpSystemServices_Android.h

@@ -1,27 +1,29 @@
 #pragma once
 
-#include "HostSystemServices.h"
+#include "GpSystemServices_POSIX.h"
 #include "GpCoreDefs.h"
 
-class GpSystemServices_Android final : public PortabilityLayer::HostSystemServices
+class GpSystemServices_Android final : public GpSystemServices_POSIX
 {
 public:
 	GpSystemServices_Android();
 
-	int64_t GetTime() const override;
-	void GetLocalDateTime(unsigned int &year, unsigned int &month, unsigned int &day, unsigned int &hour, unsigned int &minute, unsigned int &second) const override;
-	PortabilityLayer::HostMutex *CreateMutex() override;
-	PortabilityLayer::HostMutex *CreateRecursiveMutex() override;
 	void *CreateThread(ThreadFunc_t threadFunc, void *context) override;
-	PortabilityLayer::HostThreadEvent *CreateThreadEvent(bool autoReset, bool startSignaled) override;
-	uint64_t GetFreeMemoryCosmetic() const override;
-	void Beep() const override;
+	bool Beep() const override;
 	bool IsTouchscreen() const override;
 	bool IsUsingMouseAsTouch() const override;
 	bool IsTextInputObstructive() const override;
+	bool IsFullscreenPreferred() const override;
+	bool IsFullscreenOnStartup() const override;
+	bool HasNativeFileManager() const override;
+	GpOperatingSystem_t GetOperatingSystem() const override;
+	GpOperatingSystemFlavor_t GetOperatingSystemFlavor() const override;
 	unsigned int GetCPUCount() const override;
 	void SetTextInputEnabled(bool isEnabled) override;
 	bool IsTextInputEnabled() const override;
+	bool AreFontResourcesSeekable() const override;
+	IGpClipboardContents *GetClipboardContents() const override;
+	void SetClipboardContents(IGpClipboardContents *contents) override;
 
 	void FlushTextInputEnabled();
 

AerofoilAndroid/app/src/main/AndroidManifest.xml

@@ -41,9 +41,13 @@
     <!-- Allow writing to external storage -->
     <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />
     <!-- Allow access to Bluetooth devices -->
+	<!--
     <uses-permission android:name="android.permission.BLUETOOTH" />
+	-->
     <!-- Allow access to the vibrator -->
+	<!--
     <uses-permission android:name="android.permission.VIBRATE" />
+	-->
 
     <!-- if you want to capture audio, uncomment this. -->
     <!-- <uses-permission android:name="android.permission.RECORD_AUDIO" /> -->

AerofoilAndroid/build.gradle

@@ -6,7 +6,7 @@ buildscript {
         google()
     }
     dependencies {
-        classpath 'com.android.tools.build:gradle:4.1.0'
+        classpath 'com.android.tools.build:gradle:4.1.1'
 
         // NOTE: Do not place your application dependencies here; they belong
         // in the individual module build.gradle files

AerofoilAndroid/copy_packaged_resources.bat

@@ -7,6 +7,6 @@ mkdir Packaged
 cd Packaged
 rmdir /S /Q Houses
 mkdir Houses
-copy ..\..\..\..\..\..\Packaged\*.gpa .\
+copy ..\..\..\..\..\..\Packaged\*.gpf .\
 copy ..\..\..\..\..\..\Packaged\Houses\* Houses\
 cd ..

AerofoilAndroid/copy_source_package.bat

@@ -6,3 +6,4 @@ git archive -0 --format zip -o AerofoilAndroid\app\src\main\assets\Packaged\Sour
 tools\7z.exe d AerofoilAndroid\app\src\main\assets\Packaged\SourceCode.zip GliderProData\
 cd AerofoilAndroid\app\src\main\assets\Packaged
 rename SourceCode.zip SourceCode.pkg
+pause

AerofoilAndroid/make_symlinks.bat

@@ -5,17 +5,15 @@ call remove_symlinks.bat
 
 
 mklink /D app\jni\AerofoilSDL ..\..\..\AerofoilSDL
+mklink /D app\jni\AerofoilPortable ..\..\..\AerofoilPortable
 mklink /D app\jni\Common ..\..\..\Common
 mklink /D app\jni\SDL2 ..\..\..\SDL2-2.0.12
 mklink /D app\jni\GpApp ..\..\..\GpApp
 mklink /D app\jni\GpShell ..\..\..\GpShell
 mklink /D app\jni\GpCommon ..\..\..\GpCommon
-mklink /D app\jni\GpFontHandler_FreeType2 ..\..\..\GpFontHandler_FreeType2
 mklink /D app\jni\PortabilityLayer ..\..\..\PortabilityLayer
-mklink /D app\jni\FreeType ..\..\..\FreeType
 mklink /D app\jni\rapidjson ..\..\..\rapidjson
 mklink /D app\jni\MacRomanConversion ..\..\..\MacRomanConversion
 mklink /D app\jni\stb ..\..\..\stb
-mklink /D app\src\main\assets\Resources ..\..\..\..\..\Resources
 
 pause

AerofoilAndroid/remove_symlinks.bat

@@ -2,16 +2,13 @@
 @cd /d "%~dp0"
 
 rmdir app\jni\AerofoilSDL
+rmdir app\jni\AerofoilPortable
 rmdir app\jni\Common
 rmdir app\jni\SDL2
 rmdir app\jni\GpShell
 rmdir app\jni\GpCommon
 rmdir app\jni\GpApp
-rmdir app\jni\GpFontHandler_FreeType2
 rmdir app\jni\PortabilityLayer
-rmdir app\jni\FreeType
-rmdir app\jni\zlib
 rmdir app\jni\rapidjson
 rmdir app\jni\MacRomanConversion
 rmdir app\jni\stb
-rmdir app\src\main\assets\Resources

AerofoilMac/AerofoilMac.xcodeproj/project.xcworkspace/contents.xcworkspacedata

@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<Workspace
+   version = "1.0">
+   <FileRef
+      location = "self:">
+   </FileRef>
+</Workspace>

AerofoilMac/AerofoilMac.xcodeproj/project.xcworkspace/xcshareddata/IDEWorkspaceChecks.plist

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+	<key>IDEDidComputeMac32BitWarning</key>
+	<true/>
+</dict>
+</plist>

AerofoilMac/AerofoilMac.xcodeproj/xcshareddata/xcschemes/AerofoilMac.xcscheme

@@ -0,0 +1,84 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<Scheme
+   LastUpgradeVersion = "1240"
+   version = "1.3">
+   <BuildAction
+      parallelizeBuildables = "YES"
+      buildImplicitDependencies = "YES">
+      <BuildActionEntries>
+         <BuildActionEntry
+            buildForTesting = "YES"
+            buildForRunning = "YES"
+            buildForProfiling = "YES"
+            buildForArchiving = "YES"
+            buildForAnalyzing = "YES">
+            <BuildableReference
+               BuildableIdentifier = "primary"
+               BlueprintIdentifier = "5C54D0952629B42100AB55E0"
+               BuildableName = "Aerofoil.app"
+               BlueprintName = "Aerofoil"
+               ReferencedContainer = "container:AerofoilMac.xcodeproj">
+            </BuildableReference>
+         </BuildActionEntry>
+      </BuildActionEntries>
+   </BuildAction>
+   <TestAction
+      buildConfiguration = "Debug"
+      selectedDebuggerIdentifier = "Xcode.DebuggerFoundation.Debugger.LLDB"
+      selectedLauncherIdentifier = "Xcode.DebuggerFoundation.Launcher.LLDB"
+      shouldUseLaunchSchemeArgsEnv = "YES">
+      <Testables>
+      </Testables>
+   </TestAction>
+   <LaunchAction
+      buildConfiguration = "Debug"
+      selectedDebuggerIdentifier = "Xcode.DebuggerFoundation.Debugger.LLDB"
+      selectedLauncherIdentifier = "Xcode.DebuggerFoundation.Launcher.LLDB"
+      launchStyle = "0"
+      useCustomWorkingDirectory = "NO"
+      ignoresPersistentStateOnLaunch = "NO"
+      debugDocumentVersioning = "YES"
+      debugServiceExtension = "internal"
+      allowLocationSimulation = "YES">
+      <BuildableProductRunnable
+         runnableDebuggingMode = "0">
+         <BuildableReference
+            BuildableIdentifier = "primary"
+            BlueprintIdentifier = "5C54D0952629B42100AB55E0"
+            BuildableName = "Aerofoil.app"
+            BlueprintName = "Aerofoil"
+            ReferencedContainer = "container:AerofoilMac.xcodeproj">
+         </BuildableReference>
+      </BuildableProductRunnable>
+      <CommandLineArguments>
+         <CommandLineArgument
+            argument = "-diagnostics"
+            isEnabled = "YES">
+         </CommandLineArgument>
+      </CommandLineArguments>
+   </LaunchAction>
+   <ProfileAction
+      buildConfiguration = "Release"
+      shouldUseLaunchSchemeArgsEnv = "YES"
+      savedToolIdentifier = ""
+      useCustomWorkingDirectory = "NO"
+      debugDocumentVersioning = "YES">
+      <BuildableProductRunnable
+         runnableDebuggingMode = "0">
+         <BuildableReference
+            BuildableIdentifier = "primary"
+            BlueprintIdentifier = "5C54D0952629B42100AB55E0"
+            BuildableName = "Aerofoil.app"
+            BlueprintName = "Aerofoil"
+            ReferencedContainer = "container:AerofoilMac.xcodeproj">
+         </BuildableReference>
+      </BuildableProductRunnable>
+   </ProfileAction>
+   <AnalyzeAction
+      buildConfiguration = "Debug">
+   </AnalyzeAction>
+   <ArchiveAction
+      buildConfiguration = "Release"
+      revealArchiveInOrganizer = "YES">
+   </ArchiveAction>
+</Scheme>

AerofoilMac/AerofoilMac/AerofoilMac.entitlements

@@ -0,0 +1,12 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+	<key>com.apple.security.app-sandbox</key>
+	<true/>
+	<key>com.apple.security.cs.disable-library-validation</key>
+	<true/>
+	<key>com.apple.security.files.user-selected.read-only</key>
+	<true/>
+</dict>
+</plist>

AerofoilMac/AerofoilMac/Assets.xcassets/AccentColor.colorset/Contents.json

@@ -0,0 +1,11 @@
+{
+  "colors" : [
+    {
+      "idiom" : "universal"
+    }
+  ],
+  "info" : {
+    "author" : "xcode",
+    "version" : 1
+  }
+}

AerofoilMac/AerofoilMac/Assets.xcassets/AppIcon.appiconset/Contents.json

@@ -0,0 +1 @@
+{"images":[{"size":"128x128","expected-size":"128","filename":"128.png","folder":"Assets.xcassets/AppIcon.appiconset/","idiom":"mac","scale":"1x"},{"size":"256x256","expected-size":"256","filename":"256.png","folder":"Assets.xcassets/AppIcon.appiconset/","idiom":"mac","scale":"1x"},{"size":"128x128","expected-size":"256","filename":"256.png","folder":"Assets.xcassets/AppIcon.appiconset/","idiom":"mac","scale":"2x"},{"size":"256x256","expected-size":"512","filename":"512.png","folder":"Assets.xcassets/AppIcon.appiconset/","idiom":"mac","scale":"2x"},{"size":"32x32","expected-size":"32","filename":"32.png","folder":"Assets.xcassets/AppIcon.appiconset/","idiom":"mac","scale":"1x"},{"size":"512x512","expected-size":"512","filename":"512.png","folder":"Assets.xcassets/AppIcon.appiconset/","idiom":"mac","scale":"1x"},{"size":"16x16","expected-size":"16","filename":"16.png","folder":"Assets.xcassets/AppIcon.appiconset/","idiom":"mac","scale":"1x"},{"size":"16x16","expected-size":"32","filename":"32.png","folder":"Assets.xcassets/AppIcon.appiconset/","idiom":"mac","scale":"2x"},{"size":"32x32","expected-size":"64","filename":"64.png","folder":"Assets.xcassets/AppIcon.appiconset/","idiom":"mac","scale":"2x"},{"size":"512x512","expected-size":"1024","filename":"1024.png","folder":"Assets.xcassets/AppIcon.appiconset/","idiom":"mac","scale":"2x"}]}

AerofoilMac/AerofoilMac/Assets.xcassets/Contents.json

@@ -0,0 +1,6 @@
+{
+  "info" : {
+    "author" : "xcode",
+    "version" : 1
+  }
+}

AerofoilMac/AerofoilMac/Base.lproj/Main.storyboard

@@ -0,0 +1,717 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<document type="com.apple.InterfaceBuilder3.Cocoa.Storyboard.XIB" version="3.0" toolsVersion="11134" targetRuntime="MacOSX.Cocoa" propertyAccessControl="none" useAutolayout="YES" initialViewController="B8D-0N-5wS">
+    <dependencies>
+        <plugIn identifier="com.apple.InterfaceBuilder.CocoaPlugin" version="11134"/>
+    </dependencies>
+    <scenes>
+        <!--Application-->
+        <scene sceneID="JPo-4y-FX3">
+            <objects>
+                <application id="hnw-xV-0zn" sceneMemberID="viewController">
+                    <menu key="mainMenu" title="Main Menu" systemMenu="main" id="AYu-sK-qS6">
+                        <items>
+                            <menuItem title="AerofoilMac" id="1Xt-HY-uBw">
+                                <modifierMask key="keyEquivalentModifierMask"/>
+                                <menu key="submenu" title="AerofoilMac" systemMenu="apple" id="uQy-DD-JDr">
+                                    <items>
+                                        <menuItem title="About AerofoilMac" id="5kV-Vb-QxS">
+                                            <modifierMask key="keyEquivalentModifierMask"/>
+                                            <connections>
+                                                <action selector="orderFrontStandardAboutPanel:" target="Ady-hI-5gd" id="Exp-CZ-Vem"/>
+                                            </connections>
+                                        </menuItem>
+                                        <menuItem isSeparatorItem="YES" id="VOq-y0-SEH"/>
+                                        <menuItem title="Preferences…" keyEquivalent="," id="BOF-NM-1cW"/>
+                                        <menuItem isSeparatorItem="YES" id="wFC-TO-SCJ"/>
+                                        <menuItem title="Services" id="NMo-om-nkz">
+                                            <modifierMask key="keyEquivalentModifierMask"/>
+                                            <menu key="submenu" title="Services" systemMenu="services" id="hz9-B4-Xy5"/>
+                                        </menuItem>
+                                        <menuItem isSeparatorItem="YES" id="4je-JR-u6R"/>
+                                        <menuItem title="Hide AerofoilMac" keyEquivalent="h" id="Olw-nP-bQN">
+                                            <connections>
+                                                <action selector="hide:" target="Ady-hI-5gd" id="PnN-Uc-m68"/>
+                                            </connections>
+                                        </menuItem>
+                                        <menuItem title="Hide Others" keyEquivalent="h" id="Vdr-fp-XzO">
+                                            <modifierMask key="keyEquivalentModifierMask" option="YES" command="YES"/>
+                                            <connections>
+                                                <action selector="hideOtherApplications:" target="Ady-hI-5gd" id="VT4-aY-XCT"/>
+                                            </connections>
+                                        </menuItem>
+                                        <menuItem title="Show All" id="Kd2-mp-pUS">
+                                            <modifierMask key="keyEquivalentModifierMask"/>
+                                            <connections>
+                                                <action selector="unhideAllApplications:" target="Ady-hI-5gd" id="Dhg-Le-xox"/>
+                                            </connections>
+                                        </menuItem>
+                                        <menuItem isSeparatorItem="YES" id="kCx-OE-vgT"/>
+                                        <menuItem title="Quit AerofoilMac" keyEquivalent="q" id="4sb-4s-VLi">
+                                            <connections>
+                                                <action selector="terminate:" target="Ady-hI-5gd" id="Te7-pn-YzF"/>
+                                            </connections>
+                                        </menuItem>
+                                    </items>
+                                </menu>
+                            </menuItem>
+                            <menuItem title="File" id="dMs-cI-mzQ">
+                                <modifierMask key="keyEquivalentModifierMask"/>
+                                <menu key="submenu" title="File" id="bib-Uj-vzu">
+                                    <items>
+                                        <menuItem title="New" keyEquivalent="n" id="Was-JA-tGl">
+                                            <connections>
+                                                <action selector="newDocument:" target="Ady-hI-5gd" id="4Si-XN-c54"/>
+                                            </connections>
+                                        </menuItem>
+                                        <menuItem title="Open…" keyEquivalent="o" id="IAo-SY-fd9">
+                                            <connections>
+                                                <action selector="openDocument:" target="Ady-hI-5gd" id="bVn-NM-KNZ"/>
+                                            </connections>
+                                        </menuItem>
+                                        <menuItem title="Open Recent" id="tXI-mr-wws">
+                                            <modifierMask key="keyEquivalentModifierMask"/>
+                                            <menu key="submenu" title="Open Recent" systemMenu="recentDocuments" id="oas-Oc-fiZ">
+                                                <items>
+                                                    <menuItem title="Clear Menu" id="vNY-rz-j42">
+                                                        <modifierMask key="keyEquivalentModifierMask"/>
+                                                        <connections>
+                                                            <action selector="clearRecentDocuments:" target="Ady-hI-5gd" id="Daa-9d-B3U"/>
+                                                        </connections>
+                                                    </menuItem>
+                                                </items>
+                                            </menu>
+                                        </menuItem>
+                                        <menuItem isSeparatorItem="YES" id="m54-Is-iLE"/>
+                                        <menuItem title="Close" keyEquivalent="w" id="DVo-aG-piG">
+                                            <connections>
+                                                <action selector="performClose:" target="Ady-hI-5gd" id="HmO-Ls-i7Q"/>
+                                            </connections>
+                                        </menuItem>
+                                        <menuItem title="Save…" keyEquivalent="s" id="pxx-59-PXV">
+                                            <connections>
+                                                <action selector="saveDocument:" target="Ady-hI-5gd" id="teZ-XB-qJY"/>
+                                            </connections>
+                                        </menuItem>
+                                        <menuItem title="Save As…" keyEquivalent="S" id="Bw7-FT-i3A">
+                                            <connections>
+                                                <action selector="saveDocumentAs:" target="Ady-hI-5gd" id="mDf-zr-I0C"/>
+                                            </connections>
+                                        </menuItem>
+                                        <menuItem title="Revert to Saved" keyEquivalent="r" id="KaW-ft-85H">
+                                            <connections>
+                                                <action selector="revertDocumentToSaved:" target="Ady-hI-5gd" id="iJ3-Pv-kwq"/>
+                                            </connections>
+                                        </menuItem>
+                                        <menuItem isSeparatorItem="YES" id="aJh-i4-bef"/>
+                                        <menuItem title="Page Setup…" keyEquivalent="P" id="qIS-W8-SiK">
+                                            <modifierMask key="keyEquivalentModifierMask" shift="YES" command="YES"/>
+                                            <connections>
+                                                <action selector="runPageLayout:" target="Ady-hI-5gd" id="Din-rz-gC5"/>
+                                            </connections>
+                                        </menuItem>
+                                        <menuItem title="Print…" keyEquivalent="p" id="aTl-1u-JFS">
+                                            <connections>
+                                                <action selector="print:" target="Ady-hI-5gd" id="qaZ-4w-aoO"/>
+                                            </connections>
+                                        </menuItem>
+                                    </items>
+                                </menu>
+                            </menuItem>
+                            <menuItem title="Edit" id="5QF-Oa-p0T">
+                                <modifierMask key="keyEquivalentModifierMask"/>
+                                <menu key="submenu" title="Edit" id="W48-6f-4Dl">
+                                    <items>
+                                        <menuItem title="Undo" keyEquivalent="z" id="dRJ-4n-Yzg">
+                                            <connections>
+                                                <action selector="undo:" target="Ady-hI-5gd" id="M6e-cu-g7V"/>
+                                            </connections>
+                                        </menuItem>
+                                        <menuItem title="Redo" keyEquivalent="Z" id="6dh-zS-Vam">
+                                            <connections>
+                                                <action selector="redo:" target="Ady-hI-5gd" id="oIA-Rs-6OD"/>
+                                            </connections>
+                                        </menuItem>
+                                        <menuItem isSeparatorItem="YES" id="WRV-NI-Exz"/>
+                                        <menuItem title="Cut" keyEquivalent="x" id="uRl-iY-unG">
+                                            <connections>
+                                                <action selector="cut:" target="Ady-hI-5gd" id="YJe-68-I9s"/>
+                                            </connections>
+                                        </menuItem>
+                                        <menuItem title="Copy" keyEquivalent="c" id="x3v-GG-iWU">
+                                            <connections>
+                                                <action selector="copy:" target="Ady-hI-5gd" id="G1f-GL-Joy"/>
+                                            </connections>
+                                        </menuItem>
+                                        <menuItem title="Paste" keyEquivalent="v" id="gVA-U4-sdL">
+                                            <connections>
+                                                <action selector="paste:" target="Ady-hI-5gd" id="UvS-8e-Qdg"/>
+                                            </connections>
+                                        </menuItem>
+                                        <menuItem title="Paste and Match Style" keyEquivalent="V" id="WeT-3V-zwk">
+                                            <modifierMask key="keyEquivalentModifierMask" option="YES" command="YES"/>
+                                            <connections>
+                                                <action selector="pasteAsPlainText:" target="Ady-hI-5gd" id="cEh-KX-wJQ"/>
+                                            </connections>
+                                        </menuItem>
+                                        <menuItem title="Delete" id="pa3-QI-u2k">
+                                            <modifierMask key="keyEquivalentModifierMask"/>
+                                            <connections>
+                                                <action selector="delete:" target="Ady-hI-5gd" id="0Mk-Ml-PaM"/>
+                                            </connections>
+                                        </menuItem>
+                                        <menuItem title="Select All" keyEquivalent="a" id="Ruw-6m-B2m">
+                                            <connections>
+                                                <action selector="selectAll:" target="Ady-hI-5gd" id="VNm-Mi-diN"/>
+                                            </connections>
+                                        </menuItem>
+                                        <menuItem isSeparatorItem="YES" id="uyl-h8-XO2"/>
+                                        <menuItem title="Find" id="4EN-yA-p0u">
+                                            <modifierMask key="keyEquivalentModifierMask"/>
+                                            <menu key="submenu" title="Find" id="1b7-l0-nxx">
+                                                <items>
+                                                    <menuItem title="Find…" tag="1" keyEquivalent="f" id="Xz5-n4-O0W">
+                                                        <connections>
+                                                            <action selector="performFindPanelAction:" target="Ady-hI-5gd" id="cD7-Qs-BN4"/>
+                                                        </connections>
+                                                    </menuItem>
+                                                    <menuItem title="Find and Replace…" tag="12" keyEquivalent="f" id="YEy-JH-Tfz">
+                                                        <modifierMask key="keyEquivalentModifierMask" option="YES" command="YES"/>
+                                                        <connections>
+                                                            <action selector="performFindPanelAction:" target="Ady-hI-5gd" id="WD3-Gg-5AJ"/>
+                                                        </connections>
+                                                    </menuItem>
+                                                    <menuItem title="Find Next" tag="2" keyEquivalent="g" id="q09-fT-Sye">
+                                                        <connections>
+                                                            <action selector="performFindPanelAction:" target="Ady-hI-5gd" id="NDo-RZ-v9R"/>
+                                                        </connections>
+                                                    </menuItem>
+                                                    <menuItem title="Find Previous" tag="3" keyEquivalent="G" id="OwM-mh-QMV">
+                                                        <connections>
+                                                            <action selector="performFindPanelAction:" target="Ady-hI-5gd" id="HOh-sY-3ay"/>
+                                                        </connections>
+                                                    </menuItem>
+                                                    <menuItem title="Use Selection for Find" tag="7" keyEquivalent="e" id="buJ-ug-pKt">
+                                                        <connections>
+                                                            <action selector="performFindPanelAction:" target="Ady-hI-5gd" id="U76-nv-p5D"/>
+                                                        </connections>
+                                                    </menuItem>
+                                                    <menuItem title="Jump to Selection" keyEquivalent="j" id="S0p-oC-mLd">
+                                                        <connections>
+                                                            <action selector="centerSelectionInVisibleArea:" target="Ady-hI-5gd" id="IOG-6D-g5B"/>
+                                                        </connections>
+                                                    </menuItem>
+                                                </items>
+                                            </menu>
+                                        </menuItem>
+                                        <menuItem title="Spelling and Grammar" id="Dv1-io-Yv7">
+                                            <modifierMask key="keyEquivalentModifierMask"/>
+                                            <menu key="submenu" title="Spelling" id="3IN-sU-3Bg">
+                                                <items>
+                                                    <menuItem title="Show Spelling and Grammar" keyEquivalent=":" id="HFo-cy-zxI">
+                                                        <connections>
+                                                            <action selector="showGuessPanel:" target="Ady-hI-5gd" id="vFj-Ks-hy3"/>
+                                                        </connections>
+                                                    </menuItem>
+                                                    <menuItem title="Check Document Now" keyEquivalent=";" id="hz2-CU-CR7">
+                                                        <connections>
+                                                            <action selector="checkSpelling:" target="Ady-hI-5gd" id="fz7-VC-reM"/>
+                                                        </connections>
+                                                    </menuItem>
+                                                    <menuItem isSeparatorItem="YES" id="bNw-od-mp5"/>
+                                                    <menuItem title="Check Spelling While Typing" id="rbD-Rh-wIN">
+                                                        <modifierMask key="keyEquivalentModifierMask"/>
+                                                        <connections>
+                                                            <action selector="toggleContinuousSpellChecking:" target="Ady-hI-5gd" id="7w6-Qz-0kB"/>
+                                                        </connections>
+                                                    </menuItem>
+                                                    <menuItem title="Check Grammar With Spelling" id="mK6-2p-4JG">
+                                                        <modifierMask key="keyEquivalentModifierMask"/>
+                                                        <connections>
+                                                            <action selector="toggleGrammarChecking:" target="Ady-hI-5gd" id="muD-Qn-j4w"/>
+                                                        </connections>
+                                                    </menuItem>
+                                                    <menuItem title="Correct Spelling Automatically" id="78Y-hA-62v">
+                                                        <modifierMask key="keyEquivalentModifierMask"/>
+                                                        <connections>
+                                                            <action selector="toggleAutomaticSpellingCorrection:" target="Ady-hI-5gd" id="2lM-Qi-WAP"/>
+                                                        </connections>
+                                                    </menuItem>
+                                                </items>
+                                            </menu>
+                                        </menuItem>
+                                        <menuItem title="Substitutions" id="9ic-FL-obx">
+                                            <modifierMask key="keyEquivalentModifierMask"/>
+                                            <menu key="submenu" title="Substitutions" id="FeM-D8-WVr">
+                                                <items>
+                                                    <menuItem title="Show Substitutions" id="z6F-FW-3nz">
+                                                        <modifierMask key="keyEquivalentModifierMask"/>
+                                                        <connections>
+                                                            <action selector="orderFrontSubstitutionsPanel:" target="Ady-hI-5gd" id="oku-mr-iSq"/>
+                                                        </connections>
+                                                    </menuItem>
+                                                    <menuItem isSeparatorItem="YES" id="gPx-C9-uUO"/>
+                                                    <menuItem title="Smart Copy/Paste" id="9yt-4B-nSM">
+                                                        <modifierMask key="keyEquivalentModifierMask"/>
+                                                        <connections>
+                                                            <action selector="toggleSmartInsertDelete:" target="Ady-hI-5gd" id="3IJ-Se-DZD"/>
+                                                        </connections>
+                                                    </menuItem>
+                                                    <menuItem title="Smart Quotes" id="hQb-2v-fYv">
+                                                        <modifierMask key="keyEquivalentModifierMask"/>
+                                                        <connections>
+                                                            <action selector="toggleAutomaticQuoteSubstitution:" target="Ady-hI-5gd" id="ptq-xd-QOA"/>
+                                                        </connections>
+                                                    </menuItem>
+                                                    <menuItem title="Smart Dashes" id="rgM-f4-ycn">
+                                                        <modifierMask key="keyEquivalentModifierMask"/>
+                                                        <connections>
+                                                            <action selector="toggleAutomaticDashSubstitution:" target="Ady-hI-5gd" id="oCt-pO-9gS"/>
+                                                        </connections>
+                                                    </menuItem>
+                                                    <menuItem title="Smart Links" id="cwL-P1-jid">
+                                                        <modifierMask key="keyEquivalentModifierMask"/>
+                                                        <connections>
+                                                            <action selector="toggleAutomaticLinkDetection:" target="Ady-hI-5gd" id="Gip-E3-Fov"/>
+                                                        </connections>
+                                                    </menuItem>
+                                                    <menuItem title="Data Detectors" id="tRr-pd-1PS">
+                                                        <modifierMask key="keyEquivalentModifierMask"/>
+                                                        <connections>
+                                                            <action selector="toggleAutomaticDataDetection:" target="Ady-hI-5gd" id="R1I-Nq-Kbl"/>
+                                                        </connections>
+                                                    </menuItem>
+                                                    <menuItem title="Text Replacement" id="HFQ-gK-NFA">
+                                                        <modifierMask key="keyEquivalentModifierMask"/>
+                                                        <connections>
+                                                            <action selector="toggleAutomaticTextReplacement:" target="Ady-hI-5gd" id="DvP-Fe-Py6"/>
+                                                        </connections>
+                                                    </menuItem>
+                                                </items>
+                                            </menu>
+                                        </menuItem>
+                                        <menuItem title="Transformations" id="2oI-Rn-ZJC">
+                                            <modifierMask key="keyEquivalentModifierMask"/>
+                                            <menu key="submenu" title="Transformations" id="c8a-y6-VQd">
+                                                <items>
+                                                    <menuItem title="Make Upper Case" id="vmV-6d-7jI">
+                                                        <modifierMask key="keyEquivalentModifierMask"/>
+                                                        <connections>
+                                                            <action selector="uppercaseWord:" target="Ady-hI-5gd" id="sPh-Tk-edu"/>
+                                                        </connections>
+                                                    </menuItem>
+                                                    <menuItem title="Make Lower Case" id="d9M-CD-aMd">
+                                                        <modifierMask key="keyEquivalentModifierMask"/>
+                                                        <connections>
+                                                            <action selector="lowercaseWord:" target="Ady-hI-5gd" id="iUZ-b5-hil"/>
+                                                        </connections>
+                                                    </menuItem>
+                                                    <menuItem title="Capitalize" id="UEZ-Bs-lqG">
+                                                        <modifierMask key="keyEquivalentModifierMask"/>
+                                                        <connections>
+                                                            <action selector="capitalizeWord:" target="Ady-hI-5gd" id="26H-TL-nsh"/>
+                                                        </connections>
+                                                    </menuItem>
+                                                </items>
+                                            </menu>
+                                        </menuItem>
+                                        <menuItem title="Speech" id="xrE-MZ-jX0">
+                                            <modifierMask key="keyEquivalentModifierMask"/>
+                                            <menu key="submenu" title="Speech" id="3rS-ZA-NoH">
+                                                <items>
+                                                    <menuItem title="Start Speaking" id="Ynk-f8-cLZ">
+                                                        <modifierMask key="keyEquivalentModifierMask"/>
+                                                        <connections>
+                                                            <action selector="startSpeaking:" target="Ady-hI-5gd" id="654-Ng-kyl"/>
+                                                        </connections>
+                                                    </menuItem>
+                                                    <menuItem title="Stop Speaking" id="Oyz-dy-DGm">
+                                                        <modifierMask key="keyEquivalentModifierMask"/>
+                                                        <connections>
+                                                            <action selector="stopSpeaking:" target="Ady-hI-5gd" id="dX8-6p-jy9"/>
+                                                        </connections>
+                                                    </menuItem>
+                                                </items>
+                                            </menu>
+                                        </menuItem>
+                                    </items>
+                                </menu>
+                            </menuItem>
+                            <menuItem title="Format" id="jxT-CU-nIS">
+                                <modifierMask key="keyEquivalentModifierMask"/>
+                                <menu key="submenu" title="Format" id="GEO-Iw-cKr">
+                                    <items>
+                                        <menuItem title="Font" id="Gi5-1S-RQB">
+                                            <modifierMask key="keyEquivalentModifierMask"/>
+                                            <menu key="submenu" title="Font" systemMenu="font" id="aXa-aM-Jaq">
+                                                <items>
+                                                    <menuItem title="Show Fonts" keyEquivalent="t" id="Q5e-8K-NDq">
+                                                        <connections>
+                                                            <action selector="orderFrontFontPanel:" target="YLy-65-1bz" id="WHr-nq-2xA"/>
+                                                        </connections>
+                                                    </menuItem>
+                                                    <menuItem title="Bold" tag="2" keyEquivalent="b" id="GB9-OM-e27">
+                                                        <connections>
+                                                            <action selector="addFontTrait:" target="YLy-65-1bz" id="hqk-hr-sYV"/>
+                                                        </connections>
+                                                    </menuItem>
+                                                    <menuItem title="Italic" tag="1" keyEquivalent="i" id="Vjx-xi-njq">
+                                                        <connections>
+                                                            <action selector="addFontTrait:" target="YLy-65-1bz" id="IHV-OB-c03"/>
+                                                        </connections>
+                                                    </menuItem>
+                                                    <menuItem title="Underline" keyEquivalent="u" id="WRG-CD-K1S">
+                                                        <connections>
+                                                            <action selector="underline:" target="Ady-hI-5gd" id="FYS-2b-JAY"/>
+                                                        </connections>
+                                                    </menuItem>
+                                                    <menuItem isSeparatorItem="YES" id="5gT-KC-WSO"/>
+                                                    <menuItem title="Bigger" tag="3" keyEquivalent="+" id="Ptp-SP-VEL">
+                                                        <connections>
+                                                            <action selector="modifyFont:" target="YLy-65-1bz" id="Uc7-di-UnL"/>
+                                                        </connections>
+                                                    </menuItem>
+                                                    <menuItem title="Smaller" tag="4" keyEquivalent="-" id="i1d-Er-qST">
+                                                        <connections>
+                                                            <action selector="modifyFont:" target="YLy-65-1bz" id="HcX-Lf-eNd"/>
+                                                        </connections>
+                                                    </menuItem>
+                                                    <menuItem isSeparatorItem="YES" id="kx3-Dk-x3B"/>
+                                                    <menuItem title="Kern" id="jBQ-r6-VK2">
+                                                        <modifierMask key="keyEquivalentModifierMask"/>
+                                                        <menu key="submenu" title="Kern" id="tlD-Oa-oAM">
+                                                            <items>
+                                                                <menuItem title="Use Default" id="GUa-eO-cwY">
+                                                                    <modifierMask key="keyEquivalentModifierMask"/>
+                                                                    <connections>
+                                                                        <action selector="useStandardKerning:" target="Ady-hI-5gd" id="6dk-9l-Ckg"/>
+                                                                    </connections>
+                                                                </menuItem>
+                                                                <menuItem title="Use None" id="cDB-IK-hbR">
+                                                                    <modifierMask key="keyEquivalentModifierMask"/>
+                                                                    <connections>
+                                                                        <action selector="turnOffKerning:" target="Ady-hI-5gd" id="U8a-gz-Maa"/>
+                                                                    </connections>
+                                                                </menuItem>
+                                                                <menuItem title="Tighten" id="46P-cB-AYj">
+                                                                    <modifierMask key="keyEquivalentModifierMask"/>
+                                                                    <connections>
+                                                                        <action selector="tightenKerning:" target="Ady-hI-5gd" id="hr7-Nz-8ro"/>
+                                                                    </connections>
+                                                                </menuItem>
+                                                                <menuItem title="Loosen" id="ogc-rX-tC1">
+                                                                    <modifierMask key="keyEquivalentModifierMask"/>
+                                                                    <connections>
+                                                                        <action selector="loosenKerning:" target="Ady-hI-5gd" id="8i4-f9-FKE"/>
+                                                                    </connections>
+                                                                </menuItem>
+                                                            </items>
+                                                        </menu>
+                                                    </menuItem>
+                                                    <menuItem title="Ligatures" id="o6e-r0-MWq">
+                                                        <modifierMask key="keyEquivalentModifierMask"/>
+                                                        <menu key="submenu" title="Ligatures" id="w0m-vy-SC9">
+                                                            <items>
+                                                                <menuItem title="Use Default" id="agt-UL-0e3">
+                                                                    <modifierMask key="keyEquivalentModifierMask"/>
+                                                                    <connections>
+                                                                        <action selector="useStandardLigatures:" target="Ady-hI-5gd" id="7uR-wd-Dx6"/>
+                                                                    </connections>
+                                                                </menuItem>
+                                                                <menuItem title="Use None" id="J7y-lM-qPV">
+                                                                    <modifierMask key="keyEquivalentModifierMask"/>
+                                                                    <connections>
+                                                                        <action selector="turnOffLigatures:" target="Ady-hI-5gd" id="iX2-gA-Ilz"/>
+                                                                    </connections>
+                                                                </menuItem>
+                                                                <menuItem title="Use All" id="xQD-1f-W4t">
+                                                                    <modifierMask key="keyEquivalentModifierMask"/>
+                                                                    <connections>
+                                                                        <action selector="useAllLigatures:" target="Ady-hI-5gd" id="KcB-kA-TuK"/>
+                                                                    </connections>
+                                                                </menuItem>
+                                                            </items>
+                                                        </menu>
+                                                    </menuItem>
+                                                    <menuItem title="Baseline" id="OaQ-X3-Vso">
+                                                        <modifierMask key="keyEquivalentModifierMask"/>
+                                                        <menu key="submenu" title="Baseline" id="ijk-EB-dga">
+                                                            <items>
+                                                                <menuItem title="Use Default" id="3Om-Ey-2VK">
+                                                                    <modifierMask key="keyEquivalentModifierMask"/>
+                                                                    <connections>
+                                                                        <action selector="unscript:" target="Ady-hI-5gd" id="0vZ-95-Ywn"/>
+                                                                    </connections>
+                                                                </menuItem>
+                                                                <menuItem title="Superscript" id="Rqc-34-cIF">
+                                                                    <modifierMask key="keyEquivalentModifierMask"/>
+                                                                    <connections>
+                                                                        <action selector="superscript:" target="Ady-hI-5gd" id="3qV-fo-wpU"/>
+                                                                    </connections>
+                                                                </menuItem>
+                                                                <menuItem title="Subscript" id="I0S-gh-46l">
+                                                                    <modifierMask key="keyEquivalentModifierMask"/>
+                                                                    <connections>
+                                                                        <action selector="subscript:" target="Ady-hI-5gd" id="Q6W-4W-IGz"/>
+                                                                    </connections>
+                                                                </menuItem>
+                                                                <menuItem title="Raise" id="2h7-ER-AoG">
+                                                                    <modifierMask key="keyEquivalentModifierMask"/>
+                                                                    <connections>
+                                                                        <action selector="raiseBaseline:" target="Ady-hI-5gd" id="4sk-31-7Q9"/>
+                                                                    </connections>
+                                                                </menuItem>
+                                                                <menuItem title="Lower" id="1tx-W0-xDw">
+                                                                    <modifierMask key="keyEquivalentModifierMask"/>
+                                                                    <connections>
+                                                                        <action selector="lowerBaseline:" target="Ady-hI-5gd" id="OF1-bc-KW4"/>
+                                                                    </connections>
+                                                                </menuItem>
+                                                            </items>
+                                                        </menu>
+                                                    </menuItem>
+                                                    <menuItem isSeparatorItem="YES" id="Ndw-q3-faq"/>
+                                                    <menuItem title="Show Colors" keyEquivalent="C" id="bgn-CT-cEk">
+                                                        <connections>
+                                                            <action selector="orderFrontColorPanel:" target="Ady-hI-5gd" id="mSX-Xz-DV3"/>
+                                                        </connections>
+                                                    </menuItem>
+                                                    <menuItem isSeparatorItem="YES" id="iMs-zA-UFJ"/>
+                                                    <menuItem title="Copy Style" keyEquivalent="c" id="5Vv-lz-BsD">
+                                                        <modifierMask key="keyEquivalentModifierMask" option="YES" command="YES"/>
+                                                        <connections>
+                                                            <action selector="copyFont:" target="Ady-hI-5gd" id="GJO-xA-L4q"/>
+                                                        </connections>
+                                                    </menuItem>
+                                                    <menuItem title="Paste Style" keyEquivalent="v" id="vKC-jM-MkH">
+                                                        <modifierMask key="keyEquivalentModifierMask" option="YES" command="YES"/>
+                                                        <connections>
+                                                            <action selector="pasteFont:" target="Ady-hI-5gd" id="JfD-CL-leO"/>
+                                                        </connections>
+                                                    </menuItem>
+                                                </items>
+                                            </menu>
+                                        </menuItem>
+                                        <menuItem title="Text" id="Fal-I4-PZk">
+                                            <modifierMask key="keyEquivalentModifierMask"/>
+                                            <menu key="submenu" title="Text" id="d9c-me-L2H">
+                                                <items>
+                                                    <menuItem title="Align Left" keyEquivalent="{" id="ZM1-6Q-yy1">
+                                                        <connections>
+                                                            <action selector="alignLeft:" target="Ady-hI-5gd" id="zUv-R1-uAa"/>
+                                                        </connections>
+                                                    </menuItem>
+                                                    <menuItem title="Center" keyEquivalent="|" id="VIY-Ag-zcb">
+                                                        <connections>
+                                                            <action selector="alignCenter:" target="Ady-hI-5gd" id="spX-mk-kcS"/>
+                                                        </connections>
+                                                    </menuItem>
+                                                    <menuItem title="Justify" id="J5U-5w-g23">
+                                                        <modifierMask key="keyEquivalentModifierMask"/>
+                                                        <connections>
+                                                            <action selector="alignJustified:" target="Ady-hI-5gd" id="ljL-7U-jND"/>
+                                                        </connections>
+                                                    </menuItem>
+                                                    <menuItem title="Align Right" keyEquivalent="}" id="wb2-vD-lq4">
+                                                        <connections>
+                                                            <action selector="alignRight:" target="Ady-hI-5gd" id="r48-bG-YeY"/>
+                                                        </connections>
+                                                    </menuItem>
+                                                    <menuItem isSeparatorItem="YES" id="4s2-GY-VfK"/>
+                                                    <menuItem title="Writing Direction" id="H1b-Si-o9J">
+                                                        <modifierMask key="keyEquivalentModifierMask"/>
+                                                        <menu key="submenu" title="Writing Direction" id="8mr-sm-Yjd">
+                                                            <items>
+                                                                <menuItem title="Paragraph" enabled="NO" id="ZvO-Gk-QUH">
+                                                                    <modifierMask key="keyEquivalentModifierMask"/>
+                                                                </menuItem>
+                                                                <menuItem id="YGs-j5-SAR">
+                                                                    <string key="title">	Default</string>
+                                                                    <modifierMask key="keyEquivalentModifierMask"/>
+                                                                    <connections>
+                                                                        <action selector="makeBaseWritingDirectionNatural:" target="Ady-hI-5gd" id="qtV-5e-UBP"/>
+                                                                    </connections>
+                                                                </menuItem>
+                                                                <menuItem id="Lbh-J2-qVU">
+                                                                    <string key="title">	Left to Right</string>
+                                                                    <modifierMask key="keyEquivalentModifierMask"/>
+                                                                    <connections>
+                                                                        <action selector="makeBaseWritingDirectionLeftToRight:" target="Ady-hI-5gd" id="S0X-9S-QSf"/>
+                                                                    </connections>
+                                                                </menuItem>
+                                                                <menuItem id="jFq-tB-4Kx">
+                                                                    <string key="title">	Right to Left</string>
+                                                                    <modifierMask key="keyEquivalentModifierMask"/>
+                                                                    <connections>
+                                                                        <action selector="makeBaseWritingDirectionRightToLeft:" target="Ady-hI-5gd" id="5fk-qB-AqJ"/>
+                                                                    </connections>
+                                                                </menuItem>
+                                                                <menuItem isSeparatorItem="YES" id="swp-gr-a21"/>
+                                                                <menuItem title="Selection" enabled="NO" id="cqv-fj-IhA">
+                                                                    <modifierMask key="keyEquivalentModifierMask"/>
+                                                                </menuItem>
+                                                                <menuItem id="Nop-cj-93Q">
+                                                                    <string key="title">	Default</string>
+                                                                    <modifierMask key="keyEquivalentModifierMask"/>
+                                                                    <connections>
+                                                                        <action selector="makeTextWritingDirectionNatural:" target="Ady-hI-5gd" id="lPI-Se-ZHp"/>
+                                                                    </connections>
+                                                                </menuItem>
+                                                                <menuItem id="BgM-ve-c93">
+                                                                    <string key="title">	Left to Right</string>
+                                                                    <modifierMask key="keyEquivalentModifierMask"/>
+                                                                    <connections>
+                                                                        <action selector="makeTextWritingDirectionLeftToRight:" target="Ady-hI-5gd" id="caW-Bv-w94"/>
+                                                                    </connections>
+                                                                </menuItem>
+                                                                <menuItem id="RB4-Sm-HuC">
+                                                                    <string key="title">	Right to Left</string>
+                                                                    <modifierMask key="keyEquivalentModifierMask"/>
+                                                                    <connections>
+                                                                        <action selector="makeTextWritingDirectionRightToLeft:" target="Ady-hI-5gd" id="EXD-6r-ZUu"/>
+                                                                    </connections>
+                                                                </menuItem>
+                                                            </items>
+                                                        </menu>
+                                                    </menuItem>
+                                                    <menuItem isSeparatorItem="YES" id="fKy-g9-1gm"/>
+                                                    <menuItem title="Show Ruler" id="vLm-3I-IUL">
+                                                        <modifierMask key="keyEquivalentModifierMask"/>
+                                                        <connections>
+                                                            <action selector="toggleRuler:" target="Ady-hI-5gd" id="FOx-HJ-KwY"/>
+                                                        </connections>
+                                                    </menuItem>
+                                                    <menuItem title="Copy Ruler" keyEquivalent="c" id="MkV-Pr-PK5">
+                                                        <modifierMask key="keyEquivalentModifierMask" control="YES" command="YES"/>
+                                                        <connections>
+                                                            <action selector="copyRuler:" target="Ady-hI-5gd" id="71i-fW-3W2"/>
+                                                        </connections>
+                                                    </menuItem>
+                                                    <menuItem title="Paste Ruler" keyEquivalent="v" id="LVM-kO-fVI">
+                                                        <modifierMask key="keyEquivalentModifierMask" control="YES" command="YES"/>
+                                                        <connections>
+                                                            <action selector="pasteRuler:" target="Ady-hI-5gd" id="cSh-wd-qM2"/>
+                                                        </connections>
+                                                    </menuItem>
+                                                </items>
+                                            </menu>
+                                        </menuItem>
+                                    </items>
+                                </menu>
+                            </menuItem>
+                            <menuItem title="View" id="H8h-7b-M4v">
+                                <modifierMask key="keyEquivalentModifierMask"/>
+                                <menu key="submenu" title="View" id="HyV-fh-RgO">
+                                    <items>
+                                        <menuItem title="Show Toolbar" keyEquivalent="t" id="snW-S8-Cw5">
+                                            <modifierMask key="keyEquivalentModifierMask" option="YES" command="YES"/>
+                                            <connections>
+                                                <action selector="toggleToolbarShown:" target="Ady-hI-5gd" id="BXY-wc-z0C"/>
+                                            </connections>
+                                        </menuItem>
+                                        <menuItem title="Customize Toolbar…" id="1UK-8n-QPP">
+                                            <modifierMask key="keyEquivalentModifierMask"/>
+                                            <connections>
+                                                <action selector="runToolbarCustomizationPalette:" target="Ady-hI-5gd" id="pQI-g3-MTW"/>
+                                            </connections>
+                                        </menuItem>
+                                        <menuItem isSeparatorItem="YES" id="hB3-LF-h0Y"/>
+                                        <menuItem title="Show Sidebar" keyEquivalent="s" id="kIP-vf-haE">
+                                            <modifierMask key="keyEquivalentModifierMask" control="YES" command="YES"/>
+                                            <connections>
+                                                <action selector="toggleSidebar:" target="Ady-hI-5gd" id="iwa-gc-5KM"/>
+                                            </connections>
+                                        </menuItem>
+                                        <menuItem title="Enter Full Screen" keyEquivalent="f" id="4J7-dP-txa">
+                                            <modifierMask key="keyEquivalentModifierMask" control="YES" command="YES"/>
+                                            <connections>
+                                                <action selector="toggleFullScreen:" target="Ady-hI-5gd" id="dU3-MA-1Rq"/>
+                                            </connections>
+                                        </menuItem>
+                                    </items>
+                                </menu>
+                            </menuItem>
+                            <menuItem title="Window" id="aUF-d1-5bR">
+                                <modifierMask key="keyEquivalentModifierMask"/>
+                                <menu key="submenu" title="Window" systemMenu="window" id="Td7-aD-5lo">
+                                    <items>
+                                        <menuItem title="Minimize" keyEquivalent="m" id="OY7-WF-poV">
+                                            <connections>
+                                                <action selector="performMiniaturize:" target="Ady-hI-5gd" id="VwT-WD-YPe"/>
+                                            </connections>
+                                        </menuItem>
+                                        <menuItem title="Zoom" id="R4o-n2-Eq4">
+                                            <modifierMask key="keyEquivalentModifierMask"/>
+                                            <connections>
+                                                <action selector="performZoom:" target="Ady-hI-5gd" id="DIl-cC-cCs"/>
+                                            </connections>
+                                        </menuItem>
+                                        <menuItem isSeparatorItem="YES" id="eu3-7i-yIM"/>
+                                        <menuItem title="Bring All to Front" id="LE2-aR-0XJ">
+                                            <modifierMask key="keyEquivalentModifierMask"/>
+                                            <connections>
+                                                <action selector="arrangeInFront:" target="Ady-hI-5gd" id="DRN-fu-gQh"/>
+                                            </connections>
+                                        </menuItem>
+                                    </items>
+                                </menu>
+                            </menuItem>
+                            <menuItem title="Help" id="wpr-3q-Mcd">
+                                <modifierMask key="keyEquivalentModifierMask"/>
+                                <menu key="submenu" title="Help" systemMenu="help" id="F2S-fz-NVQ">
+                                    <items>
+                                        <menuItem title="AerofoilMac Help" keyEquivalent="?" id="FKE-Sm-Kum">
+                                            <connections>
+                                                <action selector="showHelp:" target="Ady-hI-5gd" id="y7X-2Q-9no"/>
+                                            </connections>
+                                        </menuItem>
+                                    </items>
+                                </menu>
+                            </menuItem>
+                        </items>
+                    </menu>
+                    <connections>
+                        <outlet property="delegate" destination="Voe-Tx-rLC" id="PrD-fu-P6m"/>
+                    </connections>
+                </application>
+                <customObject id="Voe-Tx-rLC" customClass="AppDelegate" customModuleProvider=""/>
+                <customObject id="YLy-65-1bz" customClass="NSFontManager"/>
+                <customObject id="Ady-hI-5gd" userLabel="First Responder" customClass="NSResponder" sceneMemberID="firstResponder"/>
+            </objects>
+            <point key="canvasLocation" x="75" y="0.0"/>
+        </scene>
+        <!--Window Controller-->
+        <scene sceneID="R2V-B0-nI4">
+            <objects>
+                <windowController id="B8D-0N-5wS" sceneMemberID="viewController">
+                    <window key="window" title="Window" allowsToolTipsWhenApplicationIsInactive="NO" autorecalculatesKeyViewLoop="NO" releasedWhenClosed="NO" visibleAtLaunch="NO" animationBehavior="default" id="IQv-IB-iLA">
+                        <windowStyleMask key="styleMask" titled="YES" closable="YES" miniaturizable="YES" resizable="YES"/>
+                        <windowPositionMask key="initialPositionMask" leftStrut="YES" rightStrut="YES" topStrut="YES" bottomStrut="YES"/>
+                        <rect key="contentRect" x="196" y="240" width="480" height="270"/>
+                        <rect key="screenRect" x="0.0" y="0.0" width="1680" height="1027"/>
+                        <connections>
+                            <outlet property="delegate" destination="B8D-0N-5wS" id="98r-iN-zZc"/>
+                        </connections>
+                    </window>
+                    <connections>
+                        <segue destination="XfG-lQ-9wD" kind="relationship" relationship="window.shadowedContentViewController" id="cq2-FE-JQM"/>
+                    </connections>
+                </windowController>
+                <customObject id="Oky-zY-oP4" userLabel="First Responder" customClass="NSResponder" sceneMemberID="firstResponder"/>
+            </objects>
+            <point key="canvasLocation" x="75" y="250"/>
+        </scene>
+        <!--View Controller-->
+        <scene sceneID="hIz-AP-VOD">
+            <objects>
+                <viewController id="XfG-lQ-9wD" customClass="ViewController" customModuleProvider="" sceneMemberID="viewController">
+                    <view key="view" id="m2S-Jp-Qdl">
+                        <rect key="frame" x="0.0" y="0.0" width="480" height="270"/>
+                        <autoresizingMask key="autoresizingMask"/>
+                    </view>
+                </viewController>
+                <customObject id="rPt-NT-nkU" userLabel="First Responder" customClass="NSResponder" sceneMemberID="firstResponder"/>
+            </objects>
+            <point key="canvasLocation" x="75" y="655"/>
+        </scene>
+    </scenes>
+</document>

AerofoilMac/AerofoilMac/Info.plist

@@ -0,0 +1,32 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+	<key>CFBundleDevelopmentRegion</key>
+	<string>$(DEVELOPMENT_LANGUAGE)</string>
+	<key>CFBundleExecutable</key>
+	<string>$(EXECUTABLE_NAME)</string>
+	<key>CFBundleIconFile</key>
+	<string></string>
+	<key>CFBundleIdentifier</key>
+	<string>$(PRODUCT_BUNDLE_IDENTIFIER)</string>
+	<key>CFBundleInfoDictionaryVersion</key>
+	<string>6.0</string>
+	<key>CFBundleName</key>
+	<string>$(PRODUCT_NAME)</string>
+	<key>CFBundlePackageType</key>
+	<string>$(PRODUCT_BUNDLE_PACKAGE_TYPE)</string>
+	<key>CFBundleShortVersionString</key>
+	<string>$(MARKETING_VERSION)</string>
+	<key>CFBundleVersion</key>
+	<string>1</string>
+	<key>LSApplicationCategoryType</key>
+	<string>public.app-category.arcade-games</string>
+	<key>LSMinimumSystemVersion</key>
+	<string>$(MACOSX_DEPLOYMENT_TARGET)</string>
+	<key>NSMainStoryboardFile</key>
+	<string>Main</string>
+	<key>NSPrincipalClass</key>
+	<string>NSApplication</string>
+</dict>
+</plist>

AerofoilMac/Resources/README.TXT

@@ -0,0 +1,6 @@
+Extract resources from the Windows build and place here to create the Mac build.
+Files are included in the Xcode project, but not in the Git repo.
+
+- ApplicationResources.gpf
+- Fonts.gpf
+- Houses/*.gpf

AerofoilPortable.props

@@ -0,0 +1,10 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ImportGroup Label="PropertySheets" />
+  <PropertyGroup Label="UserMacros" />
+  <PropertyGroup>
+    <IncludePath>$(SolutionDir)AerofoilPortable;$(IncludePath)</IncludePath>
+  </PropertyGroup>
+  <ItemDefinitionGroup />
+  <ItemGroup />
+</Project>

AerofoilPortable/Android.mk

@@ -2,19 +2,21 @@ LOCAL_PATH := $(call my-dir)
 
 include $(CLEAR_VARS)
 
-LOCAL_MODULE := GpFontHandler_FreeType2
+LOCAL_MODULE := AerofoilPortable
 
 LOCAL_C_INCLUDES := \
-	$(LOCAL_PATH)/../Common	\
 	$(LOCAL_PATH)/../GpCommon	\
-	$(LOCAL_PATH)/../FreeType/freetype/include
+	$(LOCAL_PATH)/../GpShell	\
+	$(LOCAL_PATH)/../Common	\
+	$(LOCAL_PATH)/../PortabilityLayer
 
 LOCAL_CFLAGS := -DGP_DEBUG_CONFIG=0
 
 # Add your application source files here...
 LOCAL_SRC_FILES := \
-	GpFontHandler_FreeType2.cpp
+	GpAllocator_C.cpp	\
+	GpThreadEvent_Cpp11.cpp	\
+	GpSystemServices_POSIX.cpp
 
-LOCAL_SHARED_LIBRARIES := FreeType
 
 include $(BUILD_STATIC_LIBRARY)

AerofoilPortable/GpAllocator_C.cpp

@@ -0,0 +1,115 @@
+#include "GpAllocator_C.h"
+#include "CoreDefs.h"
+
+#include <string.h>
+#include <stdlib.h>
+#include <assert.h>
+
+struct GpAllocator_C_MMBlock
+{
+	uint8_t m_offsetFromAllocLocation;
+
+	static size_t AlignedSize();
+};
+
+size_t GpAllocator_C_MMBlock::AlignedSize()
+{
+	const size_t paddedSize = sizeof(GpAllocator_C_MMBlock) + GP_SYSTEM_MEMORY_ALIGNMENT - 1;
+	const size_t paddedSizeTruncated = paddedSize - (paddedSize % GP_SYSTEM_MEMORY_ALIGNMENT);
+
+	return paddedSizeTruncated;
+}
+
+void *GpAllocator_C::Realloc(void *buf, size_t newSize)
+{
+	if (buf == nullptr)
+	{
+		if (newSize == 0)
+			return nullptr;
+
+		return this->Alloc(newSize);
+	}
+
+	if (newSize == 0)
+	{
+		this->Free(buf);
+		return nullptr;
+	}
+
+	assert(buf != nullptr);
+
+	const size_t mmBlockSize = GpAllocator_C_MMBlock::AlignedSize();
+	uint8_t *oldBufBytes = static_cast<uint8_t*>(buf);
+	const GpAllocator_C_MMBlock *oldBufMMBlock = reinterpret_cast<const GpAllocator_C_MMBlock*>(oldBufBytes - GpAllocator_C_MMBlock::AlignedSize());
+
+	const size_t oldBufOffsetFromAlignLoc = oldBufMMBlock->m_offsetFromAllocLocation;
+	uint8_t *oldBufBase = oldBufBytes - GpAllocator_C_MMBlock::AlignedSize() - oldBufOffsetFromAlignLoc;
+
+	const size_t mmBlockSizeWithMaxPadding = GpAllocator_C_MMBlock::AlignedSize() + GP_SYSTEM_MEMORY_ALIGNMENT - 1;
+	if (SIZE_MAX - newSize < mmBlockSizeWithMaxPadding)
+		return nullptr;
+
+	const size_t newBufferSize = newSize + mmBlockSizeWithMaxPadding;
+	uint8_t *newBuffer = static_cast<uint8_t*>(realloc(oldBufBase, newSize + mmBlockSizeWithMaxPadding));
+	if (!newBuffer)
+		return nullptr;
+
+	const intptr_t offsetFromAlignPoint = reinterpret_cast<intptr_t>(newBuffer) & static_cast<intptr_t>(GP_SYSTEM_MEMORY_ALIGNMENT - 1);
+	intptr_t alignPadding = 0;
+	if (offsetFromAlignPoint != 0)
+		alignPadding = static_cast<intptr_t>(GP_SYSTEM_MEMORY_ALIGNMENT) - offsetFromAlignPoint;
+
+	// Check if the alignment changed, if so relocate
+	if (static_cast<size_t>(alignPadding) != oldBufOffsetFromAlignLoc)
+		memmove(newBuffer + alignPadding, newBuffer + oldBufOffsetFromAlignLoc, GpAllocator_C_MMBlock::AlignedSize() + newSize);
+
+	GpAllocator_C_MMBlock *newMMBlock = reinterpret_cast<GpAllocator_C_MMBlock*>(newBuffer + alignPadding);
+	newMMBlock->m_offsetFromAllocLocation = static_cast<uint8_t>(alignPadding);
+
+	return newBuffer + alignPadding + GpAllocator_C_MMBlock::AlignedSize();
+}
+
+void *GpAllocator_C::Alloc(size_t size)
+{
+	if (size == 0)
+		return nullptr;
+
+	const size_t mmBlockSizeWithMaxPadding = GpAllocator_C_MMBlock::AlignedSize() + GP_SYSTEM_MEMORY_ALIGNMENT - 1;
+	if (SIZE_MAX - size < mmBlockSizeWithMaxPadding)
+		return nullptr;
+
+	uint8_t *buffer = static_cast<uint8_t*>(realloc(nullptr, size + mmBlockSizeWithMaxPadding));
+	if (!buffer)
+		return nullptr;
+
+	const intptr_t offsetFromAlignPoint = reinterpret_cast<intptr_t>(buffer) & static_cast<intptr_t>(GP_SYSTEM_MEMORY_ALIGNMENT - 1);
+	intptr_t alignPadding = 0;
+	if (offsetFromAlignPoint != 0)
+		alignPadding = static_cast<intptr_t>(GP_SYSTEM_MEMORY_ALIGNMENT) - offsetFromAlignPoint;
+
+	GpAllocator_C_MMBlock *mmBlock = reinterpret_cast<GpAllocator_C_MMBlock*>(buffer + alignPadding);
+	mmBlock->m_offsetFromAllocLocation = static_cast<uint8_t>(alignPadding);
+
+	return buffer + alignPadding + GpAllocator_C_MMBlock::AlignedSize();
+}
+
+void GpAllocator_C::Free(void *buf)
+{
+	if (!buf)
+		return;
+
+	const size_t mmBlockSize = GpAllocator_C_MMBlock::AlignedSize();
+
+	uint8_t *bytes = static_cast<uint8_t*>(buf);
+	const GpAllocator_C_MMBlock *mmBlock = reinterpret_cast<const GpAllocator_C_MMBlock*>(bytes - GpAllocator_C_MMBlock::AlignedSize());
+
+	void *freeLoc = bytes - GpAllocator_C_MMBlock::AlignedSize() - mmBlock->m_offsetFromAllocLocation;
+	(void)realloc(freeLoc, 0);
+}
+
+GpAllocator_C *GpAllocator_C::GetInstance()
+{
+	return &ms_instance;
+}
+
+GpAllocator_C GpAllocator_C::ms_instance;

AerofoilPortable/GpAllocator_C.h

@@ -0,0 +1,17 @@
+#pragma once
+
+#include "IGpAllocator.h"
+
+class GpAllocator_C final : public IGpAllocator
+{
+public:
+	void *Realloc(void *buf, size_t newSize) override;
+
+	static GpAllocator_C *GetInstance();
+
+private:
+	void *Alloc(size_t size);
+	void Free(void *ptr);
+
+	static GpAllocator_C ms_instance;
+};

AerofoilPortable/GpMutex_Cpp11.h

@@ -0,0 +1,66 @@
+#pragma once
+
+#include "IGpMutex.h"
+#include <mutex>
+
+template<class TMutex>
+class GpMutex_Cpp11 final : public IGpMutex
+{
+public:
+	~GpMutex_Cpp11();
+
+	void Destroy() override;
+	static GpMutex_Cpp11<TMutex> *Create();
+
+	void Lock() override;
+	void Unlock() override;
+
+private:
+	GpMutex_Cpp11();
+
+	TMutex m_mutex;
+};
+
+#include <stdlib.h>
+
+template<class TMutex>
+GpMutex_Cpp11<TMutex>::GpMutex_Cpp11()
+{
+}
+
+template<class TMutex>
+GpMutex_Cpp11<TMutex>::~GpMutex_Cpp11()
+{
+}
+
+template<class TMutex>
+void GpMutex_Cpp11<TMutex>::Destroy()
+{
+	this->~GpMutex_Cpp11();
+	free(this);
+}
+
+template<class TMutex>
+GpMutex_Cpp11<TMutex> *GpMutex_Cpp11<TMutex>::Create()
+{
+	GpMutex_Cpp11<TMutex> *mutex = static_cast<GpMutex_Cpp11<TMutex>*>(malloc(sizeof(GpMutex_Cpp11<TMutex>)));
+	if (!mutex)
+		return nullptr;
+
+	return new (mutex) GpMutex_Cpp11<TMutex>();
+}
+
+template<class TMutex>
+void GpMutex_Cpp11<TMutex>::Lock()
+{
+	m_mutex.lock();
+}
+
+template<class TMutex>
+void GpMutex_Cpp11<TMutex>::Unlock()
+{
+	m_mutex.unlock();
+}
+
+typedef GpMutex_Cpp11<std::mutex> GpMutex_Cpp11_NonRecursive;
+typedef GpMutex_Cpp11<std::recursive_mutex> GpMutex_Cpp11_Recursive;

AerofoilPortable/GpSystemServices_POSIX.cpp

@@ -0,0 +1,68 @@
+#include "GpSystemServices_POSIX.h"
+
+#include "GpMutex_Cpp11.h"
+#include "GpThreadEvent_Cpp11.h"
+
+#include <time.h>
+#include <unistd.h>
+
+#ifdef __MACOS__
+#include <sys/sysctl.h>  
+#endif
+
+GpSystemServices_POSIX::GpSystemServices_POSIX()
+{
+}
+
+int64_t GpSystemServices_POSIX::GetTime() const
+{
+	time_t t = time(nullptr);
+	return static_cast<int64_t>(t) - 2082844800;
+}
+
+void GpSystemServices_POSIX::GetLocalDateTime(unsigned int &year, unsigned int &month, unsigned int &day, unsigned int &hour, unsigned int &minute, unsigned int &second) const
+{
+	time_t t = time(nullptr);
+	tm *tmObject = localtime(&t);
+	year = static_cast<unsigned int>(tmObject->tm_year);
+	month = static_cast<unsigned int>(tmObject->tm_mon + 1);
+	hour = static_cast<unsigned int>(tmObject->tm_hour);
+	minute = static_cast<unsigned int>(tmObject->tm_min);
+	second = static_cast<unsigned int>(tmObject->tm_sec);
+}
+
+IGpMutex *GpSystemServices_POSIX::CreateMutex()
+{
+	return GpMutex_Cpp11_NonRecursive::Create();
+}
+
+IGpMutex *GpSystemServices_POSIX::CreateRecursiveMutex()
+{
+	return GpMutex_Cpp11_Recursive::Create();
+}
+
+IGpThreadEvent *GpSystemServices_POSIX::CreateThreadEvent(bool autoReset, bool startSignaled)
+{
+	return GpThreadEvent_Cpp11::Create(autoReset, startSignaled);
+}
+
+uint64_t GpSystemServices_POSIX::GetFreeMemoryCosmetic() const
+{
+	#ifdef __MACOS__
+	{ /* This works on *bsd and darwin.  */
+		unsigned int usermem;
+		size_t len = sizeof usermem;
+		static int mib[2] = { CTL_HW, HW_USERMEM };
+
+		if (sysctl (mib, 2, &usermem, &len, NULL, 0) == 0
+		&& len == sizeof (usermem))
+		return (long) usermem;
+	}
+
+	return 0;
+	#else
+	long pages = sysconf(_SC_AVPHYS_PAGES);
+	long pageSize = sysconf(_SC_PAGE_SIZE);
+	return pages * pageSize;
+	#endif
+}

AerofoilPortable/GpSystemServices_POSIX.h

@@ -0,0 +1,17 @@
+#pragma once
+
+#include "IGpSystemServices.h"
+#include "GpCoreDefs.h"
+
+class GpSystemServices_POSIX : public IGpSystemServices
+{
+public:
+	GpSystemServices_POSIX();
+
+	int64_t GetTime() const override;
+	void GetLocalDateTime(unsigned int &year, unsigned int &month, unsigned int &day, unsigned int &hour, unsigned int &minute, unsigned int &second) const override;
+	IGpMutex *CreateMutex() override;
+	IGpMutex *CreateRecursiveMutex() override;
+	IGpThreadEvent *CreateThreadEvent(bool autoReset, bool startSignaled) override;
+	uint64_t GetFreeMemoryCosmetic() const override;
+};

AerofoilPortable/GpThreadEvent_Cpp11.cpp

@@ -0,0 +1,82 @@
+#include "GpThreadEvent_Cpp11.h"
+
+GpThreadEvent_Cpp11::GpThreadEvent_Cpp11(bool autoReset, bool startSignaled)
+	: m_flag(startSignaled)
+	, m_autoReset(autoReset)
+{
+}
+
+GpThreadEvent_Cpp11::~GpThreadEvent_Cpp11()
+{
+}
+
+void GpThreadEvent_Cpp11::Wait()
+{
+	std::unique_lock<std::mutex> lock(m_mutex);
+	if (m_autoReset)
+	{
+		m_cvar.wait(lock,[&]()->bool{
+			if (m_flag)
+			{
+				m_flag = false;
+				return true;
+			}
+			else
+				return false;
+		});
+	}
+	else
+		m_cvar.wait(lock,[&]()->bool{ return m_flag; });
+}
+
+bool GpThreadEvent_Cpp11::WaitTimed(uint32_t msec)
+{
+	std::unique_lock<std::mutex> lock(m_mutex);
+	if (m_autoReset)
+	{
+		if (!m_cvar.wait_for(lock, std::chrono::milliseconds(msec), [&]()->bool{
+			if (m_flag)
+			{
+				m_flag = false;
+				return true;
+			}
+			else
+				return false;
+		}))
+			return false;
+	}
+	else
+	{
+		if (!m_cvar.wait_for(lock, std::chrono::milliseconds(msec), [&]()->bool{ return m_flag; }))
+			return false;
+	}
+	return true;
+}
+
+void GpThreadEvent_Cpp11::Signal()
+{
+	m_mutex.lock();
+	m_flag = true;
+	m_mutex.unlock();
+	if (m_autoReset)
+		m_cvar.notify_one();
+	else
+		m_cvar.notify_all();
+}
+
+void GpThreadEvent_Cpp11::Destroy()
+{
+	this->~GpThreadEvent_Cpp11();
+	free(this);
+}
+
+
+GpThreadEvent_Cpp11 *GpThreadEvent_Cpp11::Create(bool autoReset, bool startSignaled)
+{
+	GpThreadEvent_Cpp11 *evt = static_cast<GpThreadEvent_Cpp11*>(malloc(sizeof(GpThreadEvent_Cpp11)));
+	if (!evt)
+		return nullptr;
+
+	return new (evt) GpThreadEvent_Cpp11(autoReset, startSignaled);
+}
+

AerofoilPortable/GpThreadEvent_Cpp11.h

@@ -0,0 +1,28 @@
+#pragma once
+
+#include "IGpThreadEvent.h"
+
+#include <mutex>
+#include <condition_variable>
+
+class GpThreadEvent_Cpp11 final : public IGpThreadEvent
+{
+public:
+	~GpThreadEvent_Cpp11();
+
+	void Wait() override;
+	bool WaitTimed(uint32_t msec) override;
+	void Signal() override;
+	void Destroy() override;
+
+	static GpThreadEvent_Cpp11 *Create(bool autoReset, bool startSignaled);
+
+private:
+	GpThreadEvent_Cpp11(bool autoReset, bool startSignaled);
+	GpThreadEvent_Cpp11() = delete;
+
+	std::mutex m_mutex;
+	std::condition_variable m_cvar;
+	bool m_flag;
+	bool m_autoReset;
+};

AerofoilSDL/AerofoilSDL.props

@@ -3,7 +3,7 @@
   <ImportGroup Label="PropertySheets" />
   <PropertyGroup Label="UserMacros" />
   <PropertyGroup>
-    <IncludePath>$(SolutionDir)SDL2-2.0.12\include;$(IncludePath)</IncludePath>
+    <IncludePath>$(SolutionDir)SDL2-2.0.12\include;$(SolutionDir)AerofoilPortable;$(IncludePath)</IncludePath>
     <LibraryPath>$(SolutionDir)SDL2-2.0.12\lib\x64;$(LibraryPath)</LibraryPath>
   </PropertyGroup>
   <ItemDefinitionGroup>

AerofoilSDL/AerofoilSDL.vcxproj

@@ -84,6 +84,7 @@
     </Link>
   </ItemDefinitionGroup>
   <ItemGroup>
+    <ClCompile Include="..\AerofoilPortable\GpAllocator_C.cpp" />
     <ClCompile Include="..\Aerofoil\GpColorCursor_Win32.cpp" />
     <ClCompile Include="..\Aerofoil\GpFileStream_Win32.cpp" />
     <ClCompile Include="..\Aerofoil\GpFileSystem_Win32.cpp" />
@@ -93,10 +94,10 @@
     <ClCompile Include="..\Aerofoil\GpThreadEvent_Win32.cpp" />
     <ClCompile Include="GpAudioDriver_SDL2.cpp" />
     <ClCompile Include="GpDisplayDriver_SDL_GL2.cpp" />
-    <ClCompile Include="GpFiberStarter_SDL.cpp" />
-    <ClCompile Include="GpFiber_SDL.cpp" />
+    <ClCompile Include="GpInputDriver_SDL_Gamepad.cpp" />
     <ClCompile Include="GpMain_SDL_Win32.cpp" />
     <ClCompile Include="ShaderCode\CopyQuadP.cpp" />
+    <ClCompile Include="ShaderCode\DrawQuad32P.cpp" />
     <ClCompile Include="ShaderCode\DrawQuadPaletteP.cpp" />
     <ClCompile Include="ShaderCode\DrawQuadV.cpp" />
     <ClCompile Include="ShaderCode\ScaleQuadP.cpp" />
@@ -111,15 +112,13 @@
     <ProjectReference Include="..\GpFontHandler_FreeType2\GpFontHandler_FreeType2.vcxproj">
       <Project>{4b564030-8985-4975-91e1-e1b2c16ae2a1}</Project>
     </ProjectReference>
-    <ProjectReference Include="..\GpInputDriver_XInput\GpInputDriver_XInput.vcxproj">
-      <Project>{17b96f07-ef92-47cd-95a5-8e6ee38ab564}</Project>
-    </ProjectReference>
     <ProjectReference Include="..\GpShell\GpShell.vcxproj">
       <Project>{10cf9b5f-61d0-4b5b-89f4-810b58fc053d}</Project>
     </ProjectReference>
   </ItemGroup>
   <ItemGroup>
     <ClInclude Include="GpFiber_SDL.h" />
+    <ClInclude Include="GpInputDriver_SDL_Gamepad.h" />
     <ClInclude Include="ShaderCode\DrawQuadPixelConstants.h" />
     <ClInclude Include="ShaderCode\Functions.h" />
   </ItemGroup>

AerofoilSDL/AerofoilSDL.vcxproj.filters

@@ -48,12 +48,6 @@
     <ClCompile Include="ShaderCode\ScaleQuadP.cpp">
       <Filter>Source Files\ShaderCode</Filter>
     </ClCompile>
-    <ClCompile Include="GpFiber_SDL.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="GpFiberStarter_SDL.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
     <ClCompile Include="GpDisplayDriver_SDL_GL2.cpp">
       <Filter>Source Files</Filter>
     </ClCompile>
@@ -66,6 +60,15 @@
     <ClCompile Include="ShaderCode\CopyQuadP.cpp">
       <Filter>Source Files\ShaderCode</Filter>
     </ClCompile>
+    <ClCompile Include="ShaderCode\DrawQuad32P.cpp">
+      <Filter>Source Files\ShaderCode</Filter>
+    </ClCompile>
+    <ClCompile Include="GpInputDriver_SDL_Gamepad.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\AerofoilPortable\GpAllocator_C.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
   </ItemGroup>
   <ItemGroup>
     <ClInclude Include="ShaderCode\Functions.h">
@@ -77,5 +80,8 @@
     <ClInclude Include="GpFiber_SDL.h">
       <Filter>Header Files</Filter>
     </ClInclude>
+    <ClInclude Include="GpInputDriver_SDL_Gamepad.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
   </ItemGroup>
 </Project>

AerofoilSDL/AerofoilSDL_Combined.cpp

@@ -0,0 +1,8 @@
+#include "GpAudioDriver_SDL2.cpp"
+#include "GpDisplayDriver_SDL_GL2.cpp"
+#include "GpInputDriver_SDL_Gamepad.cpp"
+#include "ShaderCode/CopyQuadP.cpp"
+#include "ShaderCode/DrawQuadPaletteP.cpp"
+#include "ShaderCode/DrawQuad32P.cpp"
+#include "ShaderCode/DrawQuadV.cpp"
+#include "ShaderCode/ScaleQuadP.cpp"

AerofoilSDL/Android.mk

@@ -11,6 +11,7 @@ LOCAL_C_INCLUDES := \
 	$(LOCAL_PATH)/../GpShell	\
 	$(LOCAL_PATH)/../Common	\
 	$(LOCAL_PATH)/../PortabilityLayer	\
+	$(LOCAL_PATH)/../AerofoilPortable	\
 	$(LOCAL_PATH)/$(SDL_PATH)/include
 
 LOCAL_CFLAGS := -DGP_DEBUG_CONFIG=0
@@ -19,10 +20,9 @@ LOCAL_CFLAGS := -DGP_DEBUG_CONFIG=0
 LOCAL_SRC_FILES := \
 	GpAudioDriver_SDL2.cpp	\
 	GpDisplayDriver_SDL_GL2.cpp	\
-	GpFiber_SDL.cpp	\
-	GpFiberStarter_SDL.cpp	\
 	ShaderCode/CopyQuadP.cpp	\
 	ShaderCode/DrawQuadPaletteP.cpp	\
+	ShaderCode/DrawQuad32P.cpp	\
 	ShaderCode/DrawQuadV.cpp	\
 	ShaderCode/ScaleQuadP.cpp
 

AerofoilSDL/GpAudioDriver_SDL2.cpp

@@ -1,25 +1,34 @@
+#include "CoreDefs.h"
+#include "IGpAudioBuffer.h"
 #include "IGpAudioDriver.h"
 #include "IGpAudioChannel.h"
 #include "IGpAudioChannelCallbacks.h"
+#include "IGpMutex.h"
 #include "IGpPrefsHandler.h"
+#include "IGpSystemServices.h"
 #include "GpAudioDriverProperties.h"
-#include "CoreDefs.h"
-
-#include "HostMutex.h"
-#include "HostSystemServices.h"
+#include "GpSDL.h"
 
 #include "SDL_audio.h"
 #include "GpRingBuffer.h"
 
 #include "SDL_atomic.h"
 
+#include <stddef.h>
+#include <stdint.h>
 #include <stdlib.h>
 #include <string.h>
 #include <new>
 #include <stdio.h>
+#include <chrono>
 
 class GpAudioDriver_SDL2;
 
+typedef std::chrono::high_resolution_clock::duration GpAudioDriver_SDL2_Duration_t;
+typedef std::chrono::high_resolution_clock::time_point GpAudioDriver_SDL2_TimePoint_t;
+typedef std::chrono::high_resolution_clock::period GpAudioDriver_SDL2_Period_t;
+typedef std::chrono::high_resolution_clock::rep GpAudioDriver_SDL2_Rep_t;
+
 static void *AlignedAlloc(size_t size, size_t alignment)
 {
 	void *storage = malloc(size + alignment);
@@ -46,72 +55,150 @@ static void AlignedFree(void *ptr)
 	free(storageLoc);
 }
 
-struct GpAudioChannelBufferChain_SDL2 final
-{
-	GpAudioChannelBufferChain_SDL2();
-
-	static GpAudioChannelBufferChain_SDL2 *Alloc();
-	void Release();
-
-	static const size_t kMaxCapacity = 65536;
-
-	size_t m_consumed;
-	size_t m_used;
-	uint8_t m_data[kMaxCapacity];
-	GpAudioChannelBufferChain_SDL2 *m_next;
-	bool m_hasTrigger;
-};
-
-class GP_ALIGNED(GP_SYSTEM_MEMORY_ALIGNMENT) GpAudioChannel_SDL2 final : public IGpAudioChannel
+class GpAudioBuffer_SDL2 final : public IGpAudioBuffer
 {
 public:
-	enum ChannelState
-	{
-		ChannelState_Idle,
-		ChannelState_Playing,
-		ChannelState_Stopped,
-	};
+	typedef int16_t AudioSample_t;
 
+	static GpAudioBuffer_SDL2 *Create(const void *data, size_t size);
+
+	void AddRef() override;
+	void Release() override;
+
+	const AudioSample_t *GetData() const;
+	size_t GetSize() const;
+
+private:
+	GpAudioBuffer_SDL2(const AudioSample_t *data, size_t size);
+	~GpAudioBuffer_SDL2();
+
+	void Destroy();
+
+	const AudioSample_t *m_data;
+	size_t m_size;
+	SDL_atomic_t m_count;
+};
+
+GpAudioBuffer_SDL2 *GpAudioBuffer_SDL2::Create(const void *data, size_t size)
+{
+	size_t baseSize = sizeof(GpAudioBuffer_SDL2) + GP_SYSTEM_MEMORY_ALIGNMENT + 1;
+	baseSize -= baseSize % GP_SYSTEM_MEMORY_ALIGNMENT;
+	void *storage = malloc(size * sizeof(AudioSample_t) + baseSize);
+	if (!storage)
+		return nullptr;
+
+	AudioSample_t *dataPos = reinterpret_cast<AudioSample_t*>(static_cast<uint8_t*>(storage) + baseSize);
+
+	// Convert from u8 to s16
+	const uint8_t *srcData = static_cast<const uint8_t*>(data);
+	for (size_t i = 0; i < size; i++)
+		dataPos[i] = srcData[i] - 0x80;
+
+	return new (storage) GpAudioBuffer_SDL2(dataPos, size);
+}
+
+
+void GpAudioBuffer_SDL2::AddRef()
+{
+	SDL_AtomicAdd(&m_count, 1);
+}
+
+void GpAudioBuffer_SDL2::Release()
+{
+	int prevCount = SDL_AtomicAdd(&m_count, -1);
+	if (prevCount == 1)
+		this->Destroy();
+}
+
+const int16_t *GpAudioBuffer_SDL2::GetData() const
+{
+	return m_data;
+}
+
+size_t GpAudioBuffer_SDL2::GetSize() const
+{
+	return m_size;
+}
+
+
+GpAudioBuffer_SDL2::GpAudioBuffer_SDL2(const int16_t *data, size_t size)
+	: m_data(data)
+	, m_size(size)
+{
+	SDL_AtomicSet(&m_count, 1);
+}
+
+GpAudioBuffer_SDL2::~GpAudioBuffer_SDL2()
+{
+}
+
+void GpAudioBuffer_SDL2::Destroy()
+{
+	this->~GpAudioBuffer_SDL2();
+	free(this);
+}
+
+
+class GpAudioChannel_SDL2 final : public IGpAudioChannel
+{
+public:
 	friend class GpAudioDriver_SDL2;
+	typedef GpAudioBuffer_SDL2::AudioSample_t AudioSample_t;
 
-	GpAudioChannel_SDL2();
+	GpAudioChannel_SDL2(GpAudioDriver_SDL2_Duration_t latency, GpAudioDriver_SDL2_Duration_t bufferTime, size_t bufferSamplesMax, uint16_t sampleRate);
 	~GpAudioChannel_SDL2();
 
 	void AddRef();
 	void Release();
 
 	void SetAudioChannelContext(IGpAudioChannelCallbacks *callbacks) override;
-	void PostBuffer(const void *buffer, size_t bufferSize) override;
+	bool PostBuffer(IGpAudioBuffer *buffer) override;
 	void Stop() override;
 	void Destroy() override;
 
-	void Consume(uint8_t *output, size_t sz);
+	void Consume(int16_t *output, size_t sz, GpAudioDriver_SDL2_TimePoint_t mixStartTime, GpAudioDriver_SDL2_TimePoint_t mixEndTime);
 
-	static GpAudioChannel_SDL2 *Alloc(GpAudioDriver_SDL2 *driver);
+	static GpAudioChannel_SDL2 *Alloc(GpAudioDriver_SDL2 *driver, GpAudioDriver_SDL2_Duration_t latency, GpAudioDriver_SDL2_Duration_t bufferTime, size_t bufferSamplesMax, uint16_t sampleRate);
 
 private:
 	bool Init(GpAudioDriver_SDL2 *driver);
 
+	static const size_t kMaxBuffers = 16;
+
 	IGpAudioChannelCallbacks *m_callbacks;
-	PortabilityLayer::HostMutex *m_mutex;
+	IGpMutex *m_mutex;
 	GpAudioDriver_SDL2 *m_owner;
 
 	SDL_atomic_t m_refCount;
 
-	GpAudioChannelBufferChain_SDL2 *m_firstPendingBuffer;
-	GpAudioChannelBufferChain_SDL2 *m_lastPendingBuffer;
+	GpAudioBuffer_SDL2 *m_pendingBuffers[kMaxBuffers];
+	size_t m_nextPendingBufferConsumePos;
+	size_t m_nextPendingBufferInsertionPos;
+	size_t m_numQueuedBuffers;
+	size_t m_firstBufferSamplesConsumed;
 
-	ChannelState m_channelState;
+	GpAudioDriver_SDL2_TimePoint_t m_timestamp;		// Time that audio will be consumed if posted to the channel, if m_hasTimestamp is true.
+	GpAudioDriver_SDL2_Duration_t m_latency;
+	GpAudioDriver_SDL2_Duration_t m_bufferTime;
+	size_t m_bufferSamplesMax;
+	size_t m_leadingSilence;
+	uint16_t m_sampleRate;
+	bool m_isMixing;
+	bool m_hasTimestamp;
 };
 
-class GP_ALIGNED(GP_SYSTEM_MEMORY_ALIGNMENT) GpAudioDriver_SDL2 final : public IGpAudioDriver, public IGpPrefsHandler
+class GpAudioDriver_SDL2 final : public IGpAudioDriver, public IGpPrefsHandler
 {
 public:
 	friend class GpAudioChannel_SDL2;
 
+	typedef GpAudioChannel_SDL2::AudioSample_t AudioSample_t;
+
+
 	explicit GpAudioDriver_SDL2(const GpAudioDriverProperties &properties);
 	~GpAudioDriver_SDL2();
 
+	IGpAudioBuffer *CreateBuffer(const void *data, size_t size) override;
 	IGpAudioChannel *CreateChannel() override;
 	void SetMasterVolume(uint32_t vol, uint32_t maxVolume) override;
 	void Shutdown() override;
@@ -122,60 +209,59 @@ public:
 
 	bool Init();
 
+	static GpAudioDriver_SDL2_TimePoint_t GetCurrentTime();
+
 private:
 	void DetachAudioChannel(GpAudioChannel_SDL2 *channel);
 
 	static void SDLCALL StaticMixAudio(void *userdata, Uint8 *stream, int len);
 
 	void MixAudio(void *stream, size_t len);
-	void RefillMixChunk(GpAudioChannel_SDL2 *const*channels, size_t numChannels);
+	void RefillMixChunk(GpAudioChannel_SDL2 *const*channels, size_t numChannels, size_t maxSamplesToFill, GpAudioDriver_SDL2_TimePoint_t mixStartTime, GpAudioDriver_SDL2_TimePoint_t mixEndTime);
+	static void AddSamples(AudioSample_t *GP_RESTRICT dest, const AudioSample_t *GP_RESTRICT src, size_t nSamples);
 
 	GpAudioDriverProperties m_properties;
-	PortabilityLayer::HostMutex *m_mutex;
-	PortabilityLayer::HostMutex *m_mixState;
+	IGpMutex *m_mutex;
+	IGpMutex *m_mixState;
 
 	static const size_t kMaxChannels = 16;
-	static const size_t kMixChunkSize = 256;
+	static const size_t kMixChunkSamples = 512;
+	static const int16_t kMaxAudioVolumeScale = 64;
 
 	GpAudioChannel_SDL2 *m_channels[kMaxChannels];
 	size_t m_numChannels;
 
+	unsigned int m_sampleRate;
+	GpAudioDriver_SDL2_Duration_t m_latency;
+	GpAudioDriver_SDL2_Duration_t m_bufferTime;
+	size_t m_bufferSamples;
+
 	bool m_sdlAudioRunning;
 
-	GP_ALIGNED(GP_SYSTEM_MEMORY_ALIGNMENT) int16_t m_mixChunk[kMixChunkSize];
+	GP_ALIGNED(GP_SYSTEM_MEMORY_ALIGNMENT) int16_t m_mixChunk[kMixChunkSamples];
 	size_t m_mixChunkReadOffset;
+
+	int16_t m_audioVolumeScale;
 };
 
-GpAudioChannelBufferChain_SDL2::GpAudioChannelBufferChain_SDL2()
-	: m_used(0)
-	, m_consumed(0)
-	, m_next(nullptr)
-	, m_hasTrigger(false)
-{
-}
-
-
-GpAudioChannelBufferChain_SDL2 *GpAudioChannelBufferChain_SDL2::Alloc()
-{
-	void *storage = AlignedAlloc(sizeof(GpAudioChannelBufferChain_SDL2), GP_SYSTEM_MEMORY_ALIGNMENT);
-	return new (storage) GpAudioChannelBufferChain_SDL2();
-}
-
-void GpAudioChannelBufferChain_SDL2::Release()
-{
-	this->~GpAudioChannelBufferChain_SDL2();
-	AlignedFree(this);
-}
-
 /////////////////////////////////////////////////////////////////////////////////////////
 // GpAudioChannel
 
-GpAudioChannel_SDL2::GpAudioChannel_SDL2()
+GpAudioChannel_SDL2::GpAudioChannel_SDL2(GpAudioDriver_SDL2_Duration_t latency, GpAudioDriver_SDL2_Duration_t bufferTime, size_t bufferSamplesMax, uint16_t sampleRate)
 	: m_callbacks(nullptr)
 	, m_mutex(nullptr)
 	, m_owner(nullptr)
-	, m_firstPendingBuffer(nullptr)
-	, m_lastPendingBuffer(nullptr)
+	, m_latency(latency)
+	, m_bufferTime(bufferTime)
+	, m_bufferSamplesMax(bufferSamplesMax)
+	, m_leadingSilence(0)
+	, m_sampleRate(sampleRate)
+	, m_isMixing(false)
+	, m_hasTimestamp(false)
+	, m_nextPendingBufferConsumePos(0)
+	, m_nextPendingBufferInsertionPos(0)
+	, m_numQueuedBuffers(0)
+	, m_firstBufferSamplesConsumed(0)
 {
 	SDL_AtomicSet(&m_refCount, 1);
 }
@@ -187,12 +273,7 @@ GpAudioChannel_SDL2::~GpAudioChannel_SDL2()
 	if (m_mutex)
 		m_mutex->Destroy();
 
-	while (m_firstPendingBuffer)
-	{
-		GpAudioChannelBufferChain_SDL2 *buffer = m_firstPendingBuffer;
-		m_firstPendingBuffer = buffer->m_next;
-		buffer->Release();
-	}
+	assert(m_numQueuedBuffers == 0);
 }
 
 void GpAudioChannel_SDL2::AddRef()
@@ -215,54 +296,70 @@ void GpAudioChannel_SDL2::SetAudioChannelContext(IGpAudioChannelCallbacks *callb
 	m_callbacks = callbacks;
 }
 
-void GpAudioChannel_SDL2::PostBuffer(const void *buffer, size_t bufferSize)
+bool GpAudioChannel_SDL2::PostBuffer(IGpAudioBuffer *buffer)
 {
+	buffer->AddRef();
+
 	m_mutex->Lock();
 
-	while (bufferSize > 0)
+	if (m_numQueuedBuffers == kMaxBuffers)
 	{
-		GpAudioChannelBufferChain_SDL2 *newBuffer = GpAudioChannelBufferChain_SDL2::Alloc();
-		if (newBuffer == nullptr)
-			break;
-
-		if (m_lastPendingBuffer == nullptr)
-			m_firstPendingBuffer = newBuffer;
-		else
-			m_lastPendingBuffer->m_next = newBuffer;
-		m_lastPendingBuffer = newBuffer;
-
-		size_t bufferable = newBuffer->kMaxCapacity;
-		if (bufferSize < bufferable)
-			bufferable = bufferSize;
-
-		memcpy(newBuffer->m_data, buffer, bufferable);
-
-		buffer = static_cast<const uint8_t*>(buffer) + bufferable;
-		bufferSize -= bufferable;
-		m_lastPendingBuffer->m_used = bufferable;
-		m_lastPendingBuffer->m_hasTrigger = (bufferSize == 0);
+		m_mutex->Unlock();
+		buffer->Release();
+		return false;
 	}
 
+	size_t leadingSilence = 0;
+	if (m_numQueuedBuffers == 0 && m_hasTimestamp && !m_isMixing)
+	{
+		GpAudioDriver_SDL2_TimePoint_t queueTime = GpAudioDriver_SDL2::GetCurrentTime() + m_latency;
+		if (queueTime > m_timestamp)
+		{
+			const GpAudioDriver_SDL2_Duration_t leadTime = queueTime - m_timestamp;
+
+			if (leadTime > m_bufferTime)
+				leadingSilence = m_bufferSamplesMax;
+			else
+			{
+				const GpAudioDriver_SDL2_Rep_t leadTimeRep = leadTime.count();
+				leadingSilence = leadTimeRep * static_cast<GpAudioDriver_SDL2_Rep_t>(m_sampleRate) * GpAudioDriver_SDL2_Period_t::num / GpAudioDriver_SDL2_Period_t::den;
+			}
+		}
+	}
+
+	m_leadingSilence = leadingSilence;
+
+	m_pendingBuffers[m_nextPendingBufferInsertionPos++] = static_cast<GpAudioBuffer_SDL2*>(buffer);
+	m_numQueuedBuffers++;
+
+	m_nextPendingBufferInsertionPos = m_nextPendingBufferInsertionPos % kMaxBuffers;
+
 	m_mutex->Unlock();
+
+	return true;
 }
 
 void GpAudioChannel_SDL2::Stop()
 {
 	m_mutex->Lock();
 
-	GpAudioChannelBufferChain_SDL2 *buffer = m_firstPendingBuffer;
-	m_firstPendingBuffer = nullptr;
-	m_lastPendingBuffer = nullptr;
+	m_leadingSilence = 0;
 
-	while (buffer)
+	size_t numBuffersToDischarge = m_numQueuedBuffers;
+
+	for (size_t i = 0; i < numBuffersToDischarge; i++)
 	{
-		if (buffer->m_hasTrigger && m_callbacks)
+		GpAudioBuffer_SDL2 *buffer = m_pendingBuffers[m_nextPendingBufferConsumePos];
+
+		m_nextPendingBufferConsumePos = (m_nextPendingBufferConsumePos + 1) % kMaxBuffers;
+		m_numQueuedBuffers--;
+
+		m_firstBufferSamplesConsumed = 0;
+
+		if (m_callbacks)
 			m_callbacks->NotifyBufferFinished();
 
-		GpAudioChannelBufferChain_SDL2 *nextBuffer = buffer->m_next;
 		buffer->Release();
-
-		buffer = nextBuffer;
 	}
 
 	m_mutex->Unlock();
@@ -286,25 +383,57 @@ bool GpAudioChannel_SDL2::Init(GpAudioDriver_SDL2 *driver)
 	return true;
 }
 
-void GpAudioChannel_SDL2::Consume(uint8_t *output, size_t sz)
+void GpAudioChannel_SDL2::Consume(int16_t *output, size_t sz, GpAudioDriver_SDL2_TimePoint_t mixStartTime, GpAudioDriver_SDL2_TimePoint_t mixEndTime)
 {
 	m_mutex->Lock();
 
-	while (m_firstPendingBuffer != nullptr)
+	m_isMixing = true;
+	m_hasTimestamp = true;
+	m_timestamp = mixEndTime;
+
+	if (sz <= m_leadingSilence)
 	{
-		GpAudioChannelBufferChain_SDL2 *buffer = m_firstPendingBuffer;
-		const size_t available = (buffer->m_used - buffer->m_consumed);
+		memset(output, 0, sz * sizeof(AudioSample_t));
+		m_leadingSilence -= sz;
+
+		m_isMixing = false;
+		m_mutex->Unlock();
+		return;
+	}
+	else
+	{
+		size_t leadingSilence = m_leadingSilence;
+		if (leadingSilence > 0)
+		{
+			memset(output, 0, leadingSilence * sizeof(AudioSample_t));
+			output += leadingSilence;
+			sz -= leadingSilence;
+
+			m_leadingSilence = 0;
+		}
+	}
+
+	while (m_numQueuedBuffers > 0)
+	{
+		GpAudioBuffer_SDL2 *buffer = m_pendingBuffers[m_nextPendingBufferConsumePos];
+		const int16_t *bufferData = buffer->GetData();
+		const size_t bufferSize = buffer->GetSize();
+
+		assert(m_firstBufferSamplesConsumed < bufferSize);
+
+		const size_t available = (bufferSize - m_firstBufferSamplesConsumed);
 		if (available <= sz)
 		{
-			memcpy(output, buffer->m_data + buffer->m_consumed, available);
+			memcpy(output, bufferData + m_firstBufferSamplesConsumed, available * sizeof(AudioSample_t));
 			sz -= available;
 			output += available;
 
-			m_firstPendingBuffer = buffer->m_next;
-			if (m_firstPendingBuffer == nullptr)
-				m_lastPendingBuffer = nullptr;
+			m_nextPendingBufferConsumePos = (m_nextPendingBufferConsumePos + 1) % kMaxBuffers;
+			m_numQueuedBuffers--;
 
-			if (buffer->m_hasTrigger && m_callbacks)
+			m_firstBufferSamplesConsumed = 0;
+
+			if (m_callbacks)
 				m_callbacks->NotifyBufferFinished();
 
 			buffer->Release();
@@ -314,26 +443,28 @@ void GpAudioChannel_SDL2::Consume(uint8_t *output, size_t sz)
 		}
 		else
 		{
-			memcpy(output, buffer->m_data + buffer->m_consumed, sz);
-			buffer->m_consumed += sz;
-			buffer += sz;
+			memcpy(output, bufferData + m_firstBufferSamplesConsumed, sz * sizeof(AudioSample_t));
+			m_firstBufferSamplesConsumed += sz;
+			output += sz;
 			sz = 0;
 			break;
 		}
 	}
 
+	m_isMixing = false;
+
 	m_mutex->Unlock();
 
-	memset(output, 0x80, sz);
+	memset(output, 0, sz * sizeof(AudioSample_t));
 }
 
-GpAudioChannel_SDL2 *GpAudioChannel_SDL2::Alloc(GpAudioDriver_SDL2 *driver)
+GpAudioChannel_SDL2 *GpAudioChannel_SDL2::Alloc(GpAudioDriver_SDL2 *driver, GpAudioDriver_SDL2_Duration_t latency, GpAudioDriver_SDL2_Duration_t bufferTime, size_t bufferSamplesMax, uint16_t sampleRate)
 {
 	void *storage = AlignedAlloc(sizeof(GpAudioChannel_SDL2), GP_SYSTEM_MEMORY_ALIGNMENT);
 	if (!storage)
 		return nullptr;
 
-	GpAudioChannel_SDL2 *channel = new (storage) GpAudioChannel_SDL2();
+	GpAudioChannel_SDL2 *channel = new (storage) GpAudioChannel_SDL2(latency, bufferTime, bufferSamplesMax, sampleRate);
 	if (!channel->Init(driver))
 	{
 		channel->Destroy();
@@ -351,14 +482,18 @@ GpAudioDriver_SDL2::GpAudioDriver_SDL2(const GpAudioDriverProperties &properties
 	: m_properties(properties)
 	, m_mutex(nullptr)
 	, m_numChannels(0)
+	, m_sampleRate(0)
+	, m_latency(GpAudioDriver_SDL2_Duration_t::zero())
+	, m_bufferTime(GpAudioDriver_SDL2_Duration_t::zero())
 	, m_sdlAudioRunning(false)
-	, m_mixChunkReadOffset(kMixChunkSize)
+	, m_mixChunkReadOffset(kMixChunkSamples)
+	, m_audioVolumeScale(kMaxAudioVolumeScale)
 
 {
 	for (size_t i = 0; i < kMaxChannels; i++)
 		m_channels[i] = nullptr;
 
-	for (size_t i = 0; i < kMixChunkSize; i++)
+	for (size_t i = 0; i < kMixChunkSamples; i++)
 		m_mixChunk[i] = 0;
 }
 
@@ -371,9 +506,14 @@ GpAudioDriver_SDL2::~GpAudioDriver_SDL2()
 		m_mutex->Destroy();
 }
 
+IGpAudioBuffer *GpAudioDriver_SDL2::CreateBuffer(const void *data, size_t size)
+{
+	return GpAudioBuffer_SDL2::Create(data, size);
+}
+
 IGpAudioChannel *GpAudioDriver_SDL2::CreateChannel()
 {
-	GpAudioChannel_SDL2 *newChannel = GpAudioChannel_SDL2::Alloc(this);
+	GpAudioChannel_SDL2 *newChannel = GpAudioChannel_SDL2::Alloc(this, m_latency, m_bufferTime, m_bufferSamples, m_sampleRate);
 	if (!newChannel)
 		return nullptr;
 
@@ -395,6 +535,9 @@ IGpAudioChannel *GpAudioDriver_SDL2::CreateChannel()
 
 void GpAudioDriver_SDL2::SetMasterVolume(uint32_t vol, uint32_t maxVolume)
 {
+	double scale = vol * static_cast<uint64_t>(kMaxAudioVolumeScale) / maxVolume;
+
+	m_audioVolumeScale = static_cast<int16_t>(scale);
 }
 
 void GpAudioDriver_SDL2::Shutdown()
@@ -430,7 +573,7 @@ bool GpAudioDriver_SDL2::Init()
 	requestedSpec.channels = 1;
 	requestedSpec.format = AUDIO_S16;
 	requestedSpec.freq = m_properties.m_sampleRate;
-	requestedSpec.samples = 512;
+	requestedSpec.samples = kMixChunkSamples;
 	requestedSpec.userdata = this;
 
 	if (SDL_OpenAudio(&requestedSpec, nullptr))
@@ -443,6 +586,10 @@ bool GpAudioDriver_SDL2::Init()
 	SDL_PauseAudio(0);
 
 	m_sdlAudioRunning = true;
+	m_sampleRate = requestedSpec.freq;
+	m_latency = GpAudioDriver_SDL2_Duration_t(static_cast<GpAudioDriver_SDL2_Rep_t>(GpAudioDriver_SDL2_Period_t::den * requestedSpec.samples / GpAudioDriver_SDL2_Period_t::num / m_sampleRate));
+	m_bufferTime = GpAudioDriver_SDL2_Duration_t(static_cast<GpAudioDriver_SDL2_Rep_t>(GpAudioDriver_SDL2_Period_t::den * requestedSpec.samples / GpAudioDriver_SDL2_Period_t::num / m_sampleRate));
+	m_bufferSamples = requestedSpec.samples;
 
 	return true;
 }
@@ -485,11 +632,16 @@ void GpAudioDriver_SDL2::MixAudio(void *stream, size_t len)
 	}
 	m_mutex->Unlock();
 
-	size_t samplesRemaining = len / sizeof(int16_t);
+	const size_t totalSamples = len / sizeof(int16_t);
+	size_t samplesRemaining = totalSamples;
 
+	GpAudioDriver_SDL2_TimePoint_t audioMixStartTime = GpAudioDriver_SDL2::GetCurrentTime();
+	GpAudioDriver_SDL2_TimePoint_t audioMixBlockStartTime = audioMixStartTime;
+
+	size_t samplesSinceStart = 0;
 	for (;;)
 	{
-		size_t availableInMixChunk = kMixChunkSize - m_mixChunkReadOffset;
+		size_t availableInMixChunk = kMixChunkSamples - m_mixChunkReadOffset;
 
 		if (availableInMixChunk > samplesRemaining)
 		{
@@ -503,10 +655,17 @@ void GpAudioDriver_SDL2::MixAudio(void *stream, size_t len)
 			memcpy(stream, m_mixChunk + m_mixChunkReadOffset, availableInMixChunk * sizeof(int16_t));
 
 			stream = static_cast<int16_t*>(stream) + availableInMixChunk;
-			samplesRemaining -= availableInMixChunk;
+
+			samplesSinceStart += availableInMixChunk;
+
+			GpAudioDriver_SDL2_Duration_t audioMixDurationSinceStart = GpAudioDriver_SDL2_Duration_t(static_cast<GpAudioDriver_SDL2_Rep_t>(GpAudioDriver_SDL2_Period_t::den * samplesSinceStart / GpAudioDriver_SDL2_Period_t::num / m_sampleRate));
+			GpAudioDriver_SDL2_TimePoint_t audioMixBlockEndTime = audioMixStartTime + audioMixDurationSinceStart;
 
 			m_mixChunkReadOffset = 0;
-			RefillMixChunk(mixingChannels, numChannels);
+			RefillMixChunk(mixingChannels, numChannels, samplesRemaining, audioMixBlockStartTime, audioMixBlockEndTime);
+			audioMixBlockStartTime = audioMixBlockEndTime;
+
+			samplesRemaining -= availableInMixChunk;
 		}
 	}
 
@@ -514,40 +673,66 @@ void GpAudioDriver_SDL2::MixAudio(void *stream, size_t len)
 		mixingChannels[i]->Release();
 }
 
-void GpAudioDriver_SDL2::RefillMixChunk(GpAudioChannel_SDL2 *const*channels, size_t numChannels)
+void GpAudioDriver_SDL2::RefillMixChunk(GpAudioChannel_SDL2 *const*channels, size_t numChannels, size_t maxSamplesToFill, GpAudioDriver_SDL2_TimePoint_t mixStartTime, GpAudioDriver_SDL2_TimePoint_t mixEndTime)
 {
-	uint8_t audioMixBufferUnaligned[kMixChunkSize + GP_SYSTEM_MEMORY_ALIGNMENT];
-	uint8_t *audioMixBuffer = audioMixBufferUnaligned;
+	uint8_t audioMixBufferUnaligned[kMixChunkSamples * sizeof(AudioSample_t) + GP_SYSTEM_MEMORY_ALIGNMENT];
+	uint8_t *audioMixBufferBytes = audioMixBufferUnaligned;
 
 	{
-		uintptr_t bufferPtr = reinterpret_cast<uintptr_t>(audioMixBuffer);
+		uintptr_t bufferPtr = reinterpret_cast<uintptr_t>(audioMixBufferBytes);
 		size_t alignPadding = GP_SYSTEM_MEMORY_ALIGNMENT - (bufferPtr % GP_SYSTEM_MEMORY_ALIGNMENT);
-		audioMixBuffer += alignPadding;
+		audioMixBufferBytes += alignPadding;
 	}
 
+	AudioSample_t *audioMixBuffer = reinterpret_cast<AudioSample_t*>(audioMixBufferBytes);
 	bool noAudio = true;
 
+	const int16_t audioVolumeScale = m_audioVolumeScale;
+
+	size_t samplesToFill = kMixChunkSamples;
+	if (samplesToFill > maxSamplesToFill)
+	{
+		m_mixChunkReadOffset += samplesToFill - maxSamplesToFill;
+		samplesToFill = maxSamplesToFill;
+	}
+	else
+		m_mixChunkReadOffset = 0;
+
+	AudioSample_t *mixChunkStart = m_mixChunk + m_mixChunkReadOffset;
+
 	for (size_t i = 0; i < numChannels; i++)
 	{
-		channels[i]->Consume(audioMixBuffer, kMixChunkSize);
+		channels[i]->Consume(audioMixBuffer, samplesToFill, mixStartTime, mixEndTime);
 
 		if (i == 0)
 		{
 			noAudio = false;
-			for (size_t j = 0; j < kMixChunkSize; j++)
-				m_mixChunk[j] = (audioMixBuffer[j] - 0x80) * 25;
+			memcpy(mixChunkStart, audioMixBuffer, samplesToFill * sizeof(AudioSample_t));
 		}
 		else
-		{
-			for (size_t j = 0; j < kMixChunkSize; j++)
-				m_mixChunk[j] += (audioMixBuffer[j] - 0x80) * 25;
-		}
+			AddSamples(mixChunkStart, audioMixBuffer, samplesToFill);
 	}
 
 	if (noAudio)
-		memset(m_mixChunk, 0, kMixChunkSize * sizeof(m_mixChunk[0]));
+		memset(mixChunkStart, 0, samplesToFill * sizeof(AudioSample_t));
+	else
+	{
+		for (size_t i = 0; i < samplesToFill; i++)
+			mixChunkStart[i] *= audioVolumeScale;
+	}
 }
 
+void GpAudioDriver_SDL2::AddSamples(AudioSample_t *GP_RESTRICT dest, const AudioSample_t *GP_RESTRICT src, size_t nSamples)
+{
+	for (size_t i = 0; i < nSamples; i++)
+		dest[i] += src[i];
+}
+
+
+GpAudioDriver_SDL2_TimePoint_t GpAudioDriver_SDL2::GetCurrentTime()
+{
+	return std::chrono::high_resolution_clock::now();
+}
 
 IGpAudioDriver *GpDriver_CreateAudioDriver_SDL(const GpAudioDriverProperties &properties)
 {

AerofoilSDL/GpDisplayDriver_SDL_GL2.cpp

@@ -1,16 +1,19 @@
 #include "IGpDisplayDriver.h"
 
+#include "CoreDefs.h"
 #include "GpApplicationName.h"
 #include "GpComPtr.h"
-#include "GpFiber_SDL.h"
 #include "GpDisplayDriverProperties.h"
 #include "GpVOSEvent.h"
 #include "GpRingBuffer.h"
-#include "HostSystemServices.h"
+#include "GpInputDriver_SDL_Gamepad.h"
+#include "GpSDL.h"
+#include "GpUnicode.h"
 #include "IGpCursor.h"
 #include "IGpDisplayDriverSurface.h"
 #include "IGpLogDriver.h"
 #include "IGpPrefsHandler.h"
+#include "IGpSystemServices.h"
 #include "IGpVOSEventQueue.h"
 
 #include "SDL_events.h"
@@ -27,6 +30,9 @@
 #include <vector>
 #include <algorithm>
 
+#ifdef __EMSCRIPTEN__
+#include <emscripten.h>
+#endif
 
 #pragma push_macro("LoadCursor")
 #ifdef LoadCursor
@@ -39,68 +45,13 @@ class GpDisplayDriver_SDL_GL2;
 
 static GpDisplayDriverSurfaceEffects gs_defaultEffects;
 
+static const char *kPrefsIdentifier = "GpDisplayDriverSDL_GL2";
+static uint32_t kPrefsVersion = 1;
 
-namespace DeleteMe
+struct GpDisplayDriver_SDL_GL2_Prefs
 {
-	bool DecodeCodePoint(const uint8_t *characters, size_t availableCharacters, size_t &outCharactersDigested, uint32_t &outCodePoint)
-	{
-		if (availableCharacters <= 0)
-			return false;
-
-		if ((characters[0] & 0x80) == 0x00)
-		{
-			outCharactersDigested = 1;
-			outCodePoint = characters[0];
-			return true;
-		}
-
-		size_t sz = 0;
-		uint32_t codePoint = 0;
-		uint32_t minCodePoint = 0;
-		if ((characters[0] & 0xe0) == 0xc0)
-		{
-			sz = 2;
-			minCodePoint = 0x80;
-			codePoint = (characters[0] & 0x1f);
-		}
-		else if ((characters[0] & 0xf0) == 0xe0)
-		{
-			sz = 3;
-			minCodePoint = 0x800;
-			codePoint = (characters[0] & 0x0f);
-		}
-		else if ((characters[0] & 0xf8) == 0xf0)
-		{
-			sz = 4;
-			minCodePoint = 0x10000;
-			codePoint = (characters[0] & 0x07);
-		}
-		else
-			return false;
-
-		if (availableCharacters < sz)
-			return false;
-
-		for (size_t auxByte = 1; auxByte < sz; auxByte++)
-		{
-			if ((characters[auxByte] & 0xc0) != 0x80)
-				return false;
-
-			codePoint = (codePoint << 6) | (characters[auxByte] & 0x3f);
-		}
-
-		if (codePoint < minCodePoint || codePoint > 0x10ffff)
-			return false;
-
-		if (codePoint >= 0xd800 && codePoint <= 0xdfff)
-			return false;
-
-		outCodePoint = codePoint;
-		outCharactersDigested = sz;
-
-		return true;
-	}
-}
+	bool m_isFullScreen;
+};
 
 namespace GpBinarizedShaders
 {
@@ -108,17 +59,13 @@ namespace GpBinarizedShaders
 
 	extern const char *g_drawQuadPalettePF_GL2;
 	extern const char *g_drawQuadPalettePNF_GL2;
-	extern const char *g_drawQuadRGBPF_GL2;
-	extern const char *g_drawQuadRGBPNF_GL2;
-	extern const char *g_drawQuad15BitPF_GL2;
-	extern const char *g_drawQuad15BitPNF_GL2;
+	extern const char *g_drawQuad32PF_GL2;
+	extern const char *g_drawQuad32PNF_GL2;
 
 	extern const char *g_drawQuadPaletteICCPF_GL2;
 	extern const char *g_drawQuadPaletteICCPNF_GL2;
-	extern const char *g_drawQuadRGBICCPF_GL2;
-	extern const char *g_drawQuadRGBICCPNF_GL2;
-	extern const char *g_drawQuad15BitICCPF_GL2;
-	extern const char *g_drawQuad15BitICCPNF_GL2;
+	extern const char *g_drawQuad32ICCPF_GL2;
+	extern const char *g_drawQuad32ICCPNF_GL2;
 
 	extern const char *g_copyQuadP_GL2;
 	extern const char *g_scaleQuadP_GL2;
@@ -210,6 +157,7 @@ struct GpGLFunctions
 
 static void CheckGLError(const GpGLFunctions &gl, IGpLogDriver *logger)
 {
+#if GP_DEBUG_CONFIG
 	GLenum errorCode = gl.GetError();
 	if (errorCode != 0)
 	{
@@ -218,6 +166,7 @@ static void CheckGLError(const GpGLFunctions &gl, IGpLogDriver *logger)
 	}
 
 	assert(errorCode == 0);
+#endif
 }
 
 class GpGLObject
@@ -725,17 +674,18 @@ public:
 	explicit GpDisplayDriver_SDL_GL2(const GpDisplayDriverProperties &properties);
 	~GpDisplayDriver_SDL_GL2();
 
-	bool Init();
+	bool Init() GP_ASYNCIFY_PARANOID_OVERRIDE;
+	void ServeTicks(int tickCount) GP_ASYNCIFY_PARANOID_OVERRIDE;
+	void ForceSync() override;
+	void Shutdown() GP_ASYNCIFY_PARANOID_OVERRIDE;
 
 	void TranslateSDLMessage(const SDL_Event *msg, IGpVOSEventQueue *eventQueue, float pixelScaleX, float pixelScaleY, bool obstructiveTextInput);
 
-	void Run() override;
-	void Shutdown() override;
-	void GetDisplayResolution(unsigned int *width, unsigned int *height) override;
+	void GetInitialDisplayResolution(unsigned int *width, unsigned int *height) override;
 	IGpDisplayDriverSurface *CreateSurface(size_t width, size_t height, size_t pitch, GpPixelFormat_t pixelFormat, SurfaceInvalidateCallback_t invalidateCallback, void *invalidateContext) override;
 	void DrawSurface(IGpDisplayDriverSurface *surface, int32_t x, int32_t y, size_t width, size_t height, const GpDisplayDriverSurfaceEffects *effects) override;
-	IGpCursor *CreateBWCursor(size_t width, size_t height, const void *pixelData, const void *maskData, size_t hotSpotX, size_t hotSpotY) override;
-	IGpCursor *CreateColorCursor(size_t width, size_t height, const void *pixelDataRGBA, size_t hotSpotX, size_t hotSpotY) override;
+	IGpCursor *CreateBWCursor(size_t width, size_t height, const void *pixelData, const void *maskData, size_t hotSpotX, size_t hotSpotY) GP_ASYNCIFY_PARANOID_OVERRIDE;
+	IGpCursor *CreateColorCursor(size_t width, size_t height, const void *pixelDataRGBA, size_t hotSpotX, size_t hotSpotY) GP_ASYNCIFY_PARANOID_OVERRIDE;
 	void SetCursor(IGpCursor *cursor) override;
 	void SetStandardCursor(EGpStandardCursor_t standardCursor) override;
 	void UpdatePalette(const void *paletteData) override;
@@ -793,7 +743,7 @@ private:
 
 	void ScaleVirtualScreen();
 
-	GpDisplayDriverTickStatus_t PresentFrameAndSync();
+	bool SyncRender();
 
 	GpGLFunctions m_gl;
 	GpDisplayDriverProperties m_properties;
@@ -835,9 +785,6 @@ private:
 		GpComPtr<GpGLRenderTargetView> m_upscaleTextureRTV;
 		GpComPtr<GpGLTexture> m_upscaleTexture;
 
-		uint32_t m_upscaleTextureWidth;
-		uint32_t m_upscaleTextureHeight;
-
 		GpComPtr<GpGLVertexArray> m_quadVertexArray;
 		GpComPtr<GpGLBuffer> m_quadVertexBufferKeepalive;
 		GpComPtr<GpGLBuffer> m_quadIndexBuffer;
@@ -849,12 +796,16 @@ private:
 
 		DrawQuadProgram m_drawQuadPaletteNoFlickerProgram;
 		DrawQuadProgram m_drawQuadPaletteFlickerProgram;
-		DrawQuadProgram m_drawQuadRGBProgram;
-		DrawQuadProgram m_drawQuad15BitProgram;
+		DrawQuadProgram m_drawQuad15NoFlickerProgram;
+		DrawQuadProgram m_drawQuad15FlickerProgram;
+		DrawQuadProgram m_drawQuad32NoFlickerProgram;
+		DrawQuadProgram m_drawQuad32FlickerProgram;
 		DrawQuadProgram m_drawQuadPaletteICCNoFlickerProgram;
 		DrawQuadProgram m_drawQuadPaletteICCFlickerProgram;
-		DrawQuadProgram m_drawQuadRGBICCProgram;
-		DrawQuadProgram m_drawQuad15BitICCProgram;
+		DrawQuadProgram m_drawQuad15ICCNoFlickerProgram;
+		DrawQuadProgram m_drawQuad15ICCFlickerProgram;
+		DrawQuadProgram m_drawQuad32ICCNoFlickerProgram;
+		DrawQuadProgram m_drawQuad32ICCFlickerProgram;
 	};
 
 	InstancedResources m_res;
@@ -886,9 +837,14 @@ private:
 	uint32_t m_windowHeightPhysical;
 	uint32_t m_windowWidthVirtual;		// Virtual resolution is the resolution reported to the game
 	uint32_t m_windowHeightVirtual;
+	uint32_t m_initialWidthVirtual;		// Virtual resolution is the resolution reported to the game
+	uint32_t m_initialHeightVirtual;
 	float m_pixelScaleX;
 	float m_pixelScaleY;
+
 	bool m_useUpscaleFilter;
+	uint32_t m_upscaleTextureWidth;
+	uint32_t m_upscaleTextureHeight;
 
 	GpCursor_SDL2 *m_activeCursor;
 	GpCursor_SDL2 *m_pendingCursor;
@@ -896,9 +852,6 @@ private:
 	EGpStandardCursor_t m_pendingStandardCursor;
 	bool m_mouseIsInClientArea;
 
-	IGpFiber *m_vosFiber;
-	PortabilityLayer::HostThreadEvent *m_vosEvent;
-
 	float m_bgColor[4];
 	bool m_bgIsDark;
 
@@ -1178,11 +1131,13 @@ GpDisplayDriver_SDL_GL2::GpDisplayDriver_SDL_GL2(const GpDisplayDriverProperties
 	, m_windowHeightPhysical(480)
 	, m_windowWidthVirtual(640)
 	, m_windowHeightVirtual(480)
+	, m_initialWidthVirtual(640)
+	, m_initialHeightVirtual(480)
 	, m_pixelScaleX(1.0f)
 	, m_pixelScaleY(1.0f)
 	, m_useUpscaleFilter(false)
-	, m_vosFiber(nullptr)
-	, m_vosEvent(nullptr)
+	, m_upscaleTextureWidth(0)
+	, m_upscaleTextureHeight(0)
 	, m_pendingCursor(nullptr)
 	, m_activeCursor(nullptr)
 	, m_currentStandardCursor(EGpStandardCursors::kArrow)
@@ -1215,7 +1170,7 @@ GpDisplayDriver_SDL_GL2::GpDisplayDriver_SDL_GL2(const GpDisplayDriverProperties
 	m_bgColor[3] = 1.f;
 
 	// Stupid hack to detect mobile...
-	m_isFullScreenDesired = m_properties.m_systemServices->IsTouchscreen() && !m_properties.m_systemServices->IsUsingMouseAsTouch();
+	m_isFullScreenDesired = m_properties.m_systemServices->IsFullscreenOnStartup();
 
 	const intmax_t periodNum = std::chrono::high_resolution_clock::period::num;
 	const intmax_t periodDen = std::chrono::high_resolution_clock::period::den;
@@ -1327,9 +1282,246 @@ GpDisplayDriver_SDL_GL2::~GpDisplayDriver_SDL_GL2()
 
 bool GpDisplayDriver_SDL_GL2::Init()
 {
+#if GP_GL_IS_OPENGL_4_CONTEXT
+	SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 4);
+#else
+	SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 2);
+#endif
+	SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 0);
+
+	IGpLogDriver *logger = m_properties.m_logger;
+
+	uint32_t windowFlags = SDL_WINDOW_OPENGL | SDL_WINDOW_SHOWN;
+	if (m_properties.m_systemServices->IsFullscreenOnStartup())
+	{
+		windowFlags |= SDL_WINDOW_FULLSCREEN_DESKTOP;
+		m_isFullScreen = true;
+	}
+	else
+		windowFlags |= SDL_WINDOW_RESIZABLE;
+
+	m_window = SDL_CreateWindow(GP_APPLICATION_NAME, SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED, m_windowWidthPhysical, m_windowHeightPhysical, windowFlags);
+
+	if (m_isFullScreen)
+	{
+		m_windowModeRevertWidth = m_windowWidthPhysical;
+		m_windowModeRevertHeight = m_windowHeightPhysical;
+
+		int windowWidth = 0;
+		int windowHeight = 0;
+		SDL_GetWindowSize(m_window, &windowWidth, &windowHeight);
+
+		if (logger)
+			logger->Printf(IGpLogDriver::Category_Information, "Initialized fullscreen SDL window %i x %i", windowWidth, windowHeight);
+
+		m_windowWidthPhysical = windowWidth;
+		m_windowHeightPhysical = windowHeight;
+
+		uint32_t desiredWidth = windowWidth;
+		uint32_t desiredHeight = windowHeight;
+		uint32_t virtualWidth = m_windowWidthVirtual;
+		uint32_t virtualHeight = m_windowHeightVirtual;
+		float pixelScaleX = m_pixelScaleX;
+		float pixelScaleY = m_pixelScaleY;
+
+		if (m_properties.m_adjustRequestedResolutionFunc(m_properties.m_adjustRequestedResolutionFuncContext, desiredWidth, desiredHeight, virtualWidth, virtualHeight, pixelScaleX, pixelScaleY))
+		{
+			m_windowWidthVirtual = virtualWidth;
+			m_windowHeightVirtual = virtualHeight;
+			m_pixelScaleX = pixelScaleX;
+			m_pixelScaleY = pixelScaleY;
+
+			if (logger)
+				logger->Printf(IGpLogDriver::Category_Information, "AdjustedRequestedResolution succeeded.  Virtual dimensions %i x %i  Pixel scale %f x %f", static_cast<int>(virtualWidth), static_cast<int>(virtualHeight), static_cast<float>(pixelScaleX), static_cast<float>(pixelScaleY));
+		}
+		else
+		{
+			if (logger)
+				logger->Printf(IGpLogDriver::Category_Error, "AdjustedRequestedResolution failed!");
+		}
+	}
+
+	const bool obstructiveTextInput = m_properties.m_systemServices->IsTextInputObstructive();
+
+	if (!obstructiveTextInput)
+		SDL_StartTextInput();
+
+	StartOpenGLForWindow(logger);
+
+	if (!m_gl.LookUpFunctions())
+		return false;
+
+	m_initialWidthVirtual = m_windowWidthVirtual;
+	m_initialHeightVirtual = m_windowHeightVirtual;
+
 	return true;
 }
 
+void GpDisplayDriver_SDL_GL2::ServeTicks(int ticks)
+{
+	IGpLogDriver *logger = m_properties.m_logger;
+	const bool obstructiveTextInput = m_properties.m_systemServices->IsTextInputObstructive();
+
+	for (;;)
+	{
+		SDL_Event msg;
+		if (SDL_PollEvent(&msg) != 0)
+		{
+			switch (msg.type)
+			{
+			case SDL_MOUSEMOTION:
+			{
+				if (!m_mouseIsInClientArea)
+					m_mouseIsInClientArea = true;
+			}
+			break;
+			//case SDL_MOUSELEAVE:	// Does SDL support this??
+			//	m_mouseIsInClientArea = false;
+			//	break;
+			case SDL_RENDER_DEVICE_RESET:
+			case SDL_RENDER_TARGETS_RESET:
+			{
+				if (logger)
+					logger->Printf(IGpLogDriver::Category_Information, "Triggering GL context reset due to device loss (Type: %i)", static_cast<int>(msg.type));
+
+				m_contextLost = true;
+			}
+			break;
+			case SDL_CONTROLLERAXISMOTION:
+			case SDL_CONTROLLERBUTTONDOWN:
+			case SDL_CONTROLLERBUTTONUP:
+			case SDL_CONTROLLERDEVICEADDED:
+			case SDL_CONTROLLERDEVICEREMOVED:
+			case SDL_CONTROLLERDEVICEREMAPPED:
+				if (IGpInputDriverSDLGamepad *gamepadDriver = IGpInputDriverSDLGamepad::GetInstance())
+					gamepadDriver->ProcessSDLEvent(msg);
+				break;
+			}
+
+			TranslateSDLMessage(&msg, m_properties.m_eventQueue, m_pixelScaleX, m_pixelScaleY, obstructiveTextInput);
+		}
+		else
+		{
+			if (m_isFullScreen != m_isFullScreenDesired)
+			{
+				if (m_isFullScreenDesired)
+					BecomeFullScreen();
+				else
+					BecomeWindowed();
+
+				if (logger)
+					logger->Printf(IGpLogDriver::Category_Information, "Triggering GL context reset due to fullscreen state change");
+
+				m_contextLost = true;
+				continue;
+			}
+
+			int clientWidth = 0;
+			int clientHeight = 0;
+			SDL_GetWindowSize(m_window, &clientWidth, &clientHeight);
+
+			unsigned int desiredWidth = clientWidth;
+			unsigned int desiredHeight = clientHeight;
+			if (desiredWidth != m_windowWidthPhysical || desiredHeight != m_windowHeightPhysical || m_isResolutionResetDesired)
+			{
+				if (logger)
+					logger->Printf(IGpLogDriver::Category_Information, "Detected window size change");
+
+				uint32_t prevWidthPhysical = m_windowWidthPhysical;
+				uint32_t prevHeightPhysical = m_windowHeightPhysical;
+				uint32_t prevWidthVirtual = m_windowWidthVirtual;
+				uint32_t prevHeightVirtual = m_windowHeightVirtual;
+				uint32_t virtualWidth = m_windowWidthVirtual;
+				uint32_t virtualHeight = m_windowHeightVirtual;
+				float pixelScaleX = 1.0f;
+				float pixelScaleY = 1.0f;
+
+				if (m_properties.m_adjustRequestedResolutionFunc(m_properties.m_adjustRequestedResolutionFuncContext, desiredWidth, desiredHeight, virtualWidth, virtualHeight, pixelScaleX, pixelScaleY))
+				{
+					bool resizedOK = ResizeOpenGLWindow(m_windowWidthPhysical, m_windowHeightPhysical, desiredWidth, desiredHeight, logger);
+
+					if (!resizedOK)
+						break;	// Critical video driver error, exit
+
+					m_windowWidthVirtual = virtualWidth;
+					m_windowHeightVirtual = virtualHeight;
+					m_pixelScaleX = pixelScaleX;
+					m_pixelScaleY = pixelScaleY;
+					m_isResolutionResetDesired = false;
+
+					if (GpVOSEvent *resizeEvent = m_properties.m_eventQueue->QueueEvent())
+					{
+						resizeEvent->m_eventType = GpVOSEventTypes::kVideoResolutionChanged;
+						resizeEvent->m_event.m_resolutionChangedEvent.m_prevWidth = prevWidthVirtual;
+						resizeEvent->m_event.m_resolutionChangedEvent.m_prevHeight = prevHeightVirtual;
+						resizeEvent->m_event.m_resolutionChangedEvent.m_newWidth = m_windowWidthVirtual;
+						resizeEvent->m_event.m_resolutionChangedEvent.m_newHeight = m_windowHeightVirtual;
+					}
+
+					if (logger)
+						logger->Printf(IGpLogDriver::Category_Information, "Triggering GL context reset due to window size change");
+
+					m_contextLost = true;
+					continue;
+				}
+			}
+
+			if (m_contextLost)
+			{
+				if (logger)
+					logger->Printf(IGpLogDriver::Category_Information, "Resetting OpenGL context.  Physical: %i x %i   Virtual %i x %i", static_cast<int>(m_windowWidthPhysical), static_cast<int>(m_windowHeightPhysical), static_cast<int>(m_windowWidthVirtual), static_cast<int>(m_windowHeightVirtual));
+
+				// Drop everything and reset
+				m_res = InstancedResources();
+
+				if (m_firstSurface)
+					m_firstSurface->DestroyAll();
+
+				if (!InitResources(m_windowWidthPhysical, m_windowHeightPhysical, m_windowWidthVirtual, m_windowHeightVirtual))
+				{
+					if (logger)
+						logger->Printf(IGpLogDriver::Category_Information, "Terminating display driver due to InitResources failing");
+
+					break;
+				}
+
+				if (m_firstSurface)
+					m_firstSurface->RecreateAll();
+
+				m_contextLost = false;
+				continue;
+			}
+
+			bool wantTextInput = m_properties.m_systemServices->IsTextInputEnabled();
+			if (wantTextInput != m_textInputEnabled)
+			{
+				m_textInputEnabled = wantTextInput;
+				if (m_textInputEnabled)
+					SDL_StartTextInput();
+				else
+					SDL_StopTextInput();
+			}
+
+			// Handle dismissal of on-screen keyboard
+			const bool isTextInputActuallyActive = SDL_IsTextInputActive();
+			m_textInputEnabled = isTextInputActuallyActive;
+			m_properties.m_systemServices->SetTextInputEnabled(isTextInputActuallyActive);
+
+			if (SyncRender())
+			{
+				ticks--;
+				if (ticks <= 0)
+					break;
+			}
+		}
+	}
+}
+
+void GpDisplayDriver_SDL_GL2::ForceSync()
+{
+	m_frameTimeAccumulated = std::chrono::nanoseconds::zero();
+}
+
 static void PostMouseEvent(IGpVOSEventQueue *eventQueue, GpMouseEventType_t eventType, GpMouseButton_t button, int32_t x, int32_t y, float pixelScaleX, float pixelScaleY)
 {
 	if (GpVOSEvent *evt = eventQueue->QueueEvent())
@@ -1367,7 +1559,7 @@ static void PostTouchEvent(IGpVOSEventQueue *eventQueue, GpTouchEventType_t even
 
 static bool IdentifyVKey(const SDL_KeyboardEvent *keyEvt, GpKeyIDSubset_t &outSubset, GpKeyboardInputEvent::KeyUnion &outKey)
 {
-	SDL_KeyCode keyCode = static_cast<SDL_KeyCode>(keyEvt->keysym.sym);
+	SDL_Keycode keyCode = static_cast<SDL_Keycode>(keyEvt->keysym.sym);
 
 	switch (keyCode)
 	{
@@ -1788,7 +1980,7 @@ void GpDisplayDriver_SDL_GL2::TranslateSDLMessage(const SDL_Event *msg, IGpVOSEv
 			{
 				uint32_t codePoint;
 				size_t numDigested;
-				DeleteMe::DecodeCodePoint(reinterpret_cast<const uint8_t*>(teEvt->text) + parseOffset, lenUTF8 - parseOffset, numDigested, codePoint);
+				GpUnicode::UTF8::Decode(reinterpret_cast<const uint8_t*>(teEvt->text) + parseOffset, lenUTF8 - parseOffset, numDigested, codePoint);
 
 				parseOffset += numDigested;
 
@@ -1823,242 +2015,19 @@ void GpDisplayDriver_SDL_GL2::TranslateSDLMessage(const SDL_Event *msg, IGpVOSEv
 	}
 }
 
-void GpDisplayDriver_SDL_GL2::Run()
-{
-#if GP_GL_IS_OPENGL_4_CONTEXT
-	SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 4);
-#else
-	SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 2);
-#endif
-	SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 0);
-
-	IGpLogDriver *logger = m_properties.m_logger;
-
-	m_vosEvent = m_properties.m_systemServices->CreateThreadEvent(true, false);
-	m_vosFiber = new GpFiber_SDL(nullptr, m_vosEvent);
-
-	uint32_t windowFlags = SDL_WINDOW_OPENGL | SDL_WINDOW_SHOWN;
-	if (m_isFullScreenDesired)
-	{
-		windowFlags |= SDL_WINDOW_FULLSCREEN_DESKTOP;
-		m_isFullScreen = true;
-	}
-	else
-		windowFlags |= SDL_WINDOW_RESIZABLE;
-
-	m_window = SDL_CreateWindow(GP_APPLICATION_NAME, SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED, m_windowWidthPhysical, m_windowHeightPhysical, windowFlags);
-
-	if (m_isFullScreen)
-	{
-		m_windowModeRevertWidth = m_windowWidthPhysical;
-		m_windowModeRevertHeight = m_windowHeightPhysical;
-
-		int windowWidth = 0;
-		int windowHeight = 0;
-		SDL_GetWindowSize(m_window, &windowWidth, &windowHeight);
-
-		if (logger)
-			logger->Printf(IGpLogDriver::Category_Information, "Initialized fullscreen SDL window %i x %i", windowWidth, windowHeight);
-
-		m_windowWidthPhysical = windowWidth;
-		m_windowHeightPhysical = windowHeight;
-
-		uint32_t desiredWidth = windowWidth;
-		uint32_t desiredHeight = windowHeight;
-		uint32_t virtualWidth = m_windowWidthVirtual;
-		uint32_t virtualHeight = m_windowHeightVirtual;
-		float pixelScaleX = m_pixelScaleX;
-		float pixelScaleY = m_pixelScaleY;
-
-		if (m_properties.m_adjustRequestedResolutionFunc(m_properties.m_adjustRequestedResolutionFuncContext, desiredWidth, desiredHeight, virtualWidth, virtualHeight, pixelScaleX, pixelScaleY))
-		{
-			m_windowWidthVirtual = virtualWidth;
-			m_windowHeightVirtual = virtualHeight;
-			m_pixelScaleX = pixelScaleX;
-			m_pixelScaleY = pixelScaleY;
-
-			if (logger)
-				logger->Printf(IGpLogDriver::Category_Information, "AdjustedRequestedResolution succeeded.  Virtual dimensions %i x %i  Pixel scale %f x %f", static_cast<int>(virtualWidth), static_cast<int>(virtualHeight), static_cast<float>(pixelScaleX), static_cast<float>(pixelScaleY));
-		}
-		else
-		{
-			if (logger)
-				logger->Printf(IGpLogDriver::Category_Error, "AdjustedRequestedResolution failed!");
-		}
-	}
-
-	const bool obstructiveTextInput = m_properties.m_systemServices->IsTextInputObstructive();
-
-	if (!obstructiveTextInput)
-		SDL_StartTextInput();
-
-	StartOpenGLForWindow(logger);
-
-	if (!m_gl.LookUpFunctions())
-		return;
-
-	for (;;)
-	{
-		SDL_Event msg;
-		if (SDL_PollEvent(&msg) != 0)
-		{
-			if (msg.type == SDL_MOUSEMOTION)
-			{
-				if (!m_mouseIsInClientArea)
-					m_mouseIsInClientArea = true;
-			}
-			//else if (msg.type == SDL_MOUSELEAVE)	// Does SDL support this??
-			//	m_mouseIsInClientArea = false;
-			else if (msg.type == SDL_RENDER_DEVICE_RESET || msg.type == SDL_RENDER_TARGETS_RESET)
-			{
-				if (logger)
-					logger->Printf(IGpLogDriver::Category_Information, "Triggering GL context reset due to device loss (Type: %i)", static_cast<int>(msg.type));
-
-				m_contextLost = true;
-			}
-
-			TranslateSDLMessage(&msg, m_properties.m_eventQueue, m_pixelScaleX, m_pixelScaleY, obstructiveTextInput);
-		}
-		else
-		{
-			if (m_isFullScreen != m_isFullScreenDesired)
-			{
-				if (m_isFullScreenDesired)
-					BecomeFullScreen();
-				else
-					BecomeWindowed();
-
-				if (logger)
-					logger->Printf(IGpLogDriver::Category_Information, "Triggering GL context reset due to fullscreen state change");
-
-				m_contextLost = true;
-				continue;
-			}
-
-			int clientWidth = 0;
-			int clientHeight = 0;
-			SDL_GetWindowSize(m_window, &clientWidth, &clientHeight);
-
-			unsigned int desiredWidth = clientWidth;
-			unsigned int desiredHeight = clientHeight;
-			if (desiredWidth != m_windowWidthPhysical || desiredHeight != m_windowHeightPhysical || m_isResolutionResetDesired)
-			{
-				if (logger)
-					logger->Printf(IGpLogDriver::Category_Information, "Detected window size change");
-
-				uint32_t prevWidthPhysical = m_windowWidthPhysical;
-				uint32_t prevHeightPhysical = m_windowHeightPhysical;
-				uint32_t prevWidthVirtual = m_windowWidthVirtual;
-				uint32_t prevHeightVirtual = m_windowHeightVirtual;
-				uint32_t virtualWidth = m_windowWidthVirtual;
-				uint32_t virtualHeight = m_windowHeightVirtual;
-				float pixelScaleX = 1.0f;
-				float pixelScaleY = 1.0f;
-
-				if (m_properties.m_adjustRequestedResolutionFunc(m_properties.m_adjustRequestedResolutionFuncContext, desiredWidth, desiredHeight, virtualWidth, virtualHeight, pixelScaleX, pixelScaleY))
-				{
-					bool resizedOK = ResizeOpenGLWindow(m_windowWidthPhysical, m_windowHeightPhysical, desiredWidth, desiredHeight, logger);
-
-					if (!resizedOK)
-						break;	// Critical video driver error, exit
-
-					m_windowWidthVirtual = virtualWidth;
-					m_windowHeightVirtual = virtualHeight;
-					m_pixelScaleX = pixelScaleX;
-					m_pixelScaleY = pixelScaleY;
-					m_isResolutionResetDesired = false;
-
-					if (GpVOSEvent *resizeEvent = m_properties.m_eventQueue->QueueEvent())
-					{
-						resizeEvent->m_eventType = GpVOSEventTypes::kVideoResolutionChanged;
-						resizeEvent->m_event.m_resolutionChangedEvent.m_prevWidth = prevWidthVirtual;
-						resizeEvent->m_event.m_resolutionChangedEvent.m_prevHeight = prevHeightVirtual;
-						resizeEvent->m_event.m_resolutionChangedEvent.m_newWidth = m_windowWidthVirtual;
-						resizeEvent->m_event.m_resolutionChangedEvent.m_newHeight = m_windowHeightVirtual;
-					}
-
-					if (logger)
-						logger->Printf(IGpLogDriver::Category_Information, "Triggering GL context reset due to window size change");
-
-					m_contextLost = true;
-					continue;
-				}
-			}
-
-			if (m_contextLost)
-			{
-				if (logger)
-					logger->Printf(IGpLogDriver::Category_Information, "Resetting OpenGL context.  Physical: %i x %i   Virtual %i x %i", static_cast<int>(m_windowWidthPhysical), static_cast<int>(m_windowHeightPhysical), static_cast<int>(m_windowWidthVirtual), static_cast<int>(m_windowHeightVirtual));
-
-				// Drop everything and reset
-				m_res.~InstancedResources();
-				new (&m_res) InstancedResources();
-
-				if (m_firstSurface)
-					m_firstSurface->DestroyAll();
-
-				if (!InitResources(m_windowWidthPhysical, m_windowHeightPhysical, m_windowWidthVirtual, m_windowHeightVirtual))
-				{
-					if (logger)
-						logger->Printf(IGpLogDriver::Category_Information, "Terminating display driver due to InitResources failing");
-
-					break;
-				}
-
-				if (m_firstSurface)
-					m_firstSurface->RecreateAll();
-
-				m_contextLost = false;
-				continue;
-			}
-
-			bool wantTextInput = m_properties.m_systemServices->IsTextInputEnabled();
-			if (wantTextInput != m_textInputEnabled)
-			{
-				m_textInputEnabled = wantTextInput;
-				if (m_textInputEnabled)
-					SDL_StartTextInput();
-				else
-					SDL_StopTextInput();
-			}
-
-			// Handle dismissal of on-screen keyboard
-			const bool isTextInputActuallyActive = SDL_IsTextInputActive();
-			m_textInputEnabled = isTextInputActuallyActive;
-			m_properties.m_systemServices->SetTextInputEnabled(isTextInputActuallyActive);
-
-			GpDisplayDriverTickStatus_t tickStatus = PresentFrameAndSync();
-			if (tickStatus == GpDisplayDriverTickStatuses::kFatalFault || tickStatus == GpDisplayDriverTickStatuses::kApplicationTerminated)
-			{
-				if (logger)
-				{
-					if (tickStatus == GpDisplayDriverTickStatuses::kFatalFault)
-						logger->Printf(IGpLogDriver::Category_Information, "Terminating display driver due to fatal fault");
-					if (tickStatus == GpDisplayDriverTickStatuses::kApplicationTerminated)
-						logger->Printf(IGpLogDriver::Category_Information, "Terminating display driver due to application termination");
-				}
-
-				break;
-			}
-		}
-	}
-
-	// Exit
-}
-
 void GpDisplayDriver_SDL_GL2::Shutdown()
 {
 	this->~GpDisplayDriver_SDL_GL2();
 	free(this);
 }
 
-void GpDisplayDriver_SDL_GL2::GetDisplayResolution(unsigned int *width, unsigned int *height)
+void GpDisplayDriver_SDL_GL2::GetInitialDisplayResolution(unsigned int *width, unsigned int *height)
 {
 	if (width)
-		*width = m_windowWidthVirtual;
+		*width = m_initialWidthVirtual;
 
 	if (height)
-		*height = m_windowHeightVirtual;
+		*height = m_initialHeightVirtual;
 }
 
 IGpDisplayDriverSurface *GpDisplayDriver_SDL_GL2::CreateSurface(size_t width, size_t height, size_t pitch, GpPixelFormat_t pixelFormat, SurfaceInvalidateCallback_t invalidateCallback, void *invalidateContext)
@@ -2110,7 +2079,20 @@ void GpDisplayDriver_SDL_GL2::DrawSurface(IGpDisplayDriverSurface *surface, int3
 	}
 	else if (pixelFormat == GpPixelFormats::kRGB32)
 	{
-		return;
+		if (m_useICCProfile)
+		{
+			if (effects->m_flicker)
+				program = &m_res.m_drawQuad32ICCFlickerProgram;
+			else
+				program = &m_res.m_drawQuad32ICCNoFlickerProgram;
+		}
+		else
+		{
+			if (effects->m_flicker)
+				program = &m_res.m_drawQuad32FlickerProgram;
+			else
+				program = &m_res.m_drawQuad32NoFlickerProgram;
+		}
 	}
 	else
 	{
@@ -2338,11 +2320,19 @@ bool GpDisplayDriver_SDL_GL2::SupportsSizedFormats() const
 
 void GpDisplayDriver_SDL_GL2::ApplyPrefs(const void *identifier, size_t identifierSize, const void *contents, size_t contentsSize, uint32_t version)
 {
+	if (version == kPrefsVersion && identifierSize == strlen(kPrefsIdentifier) && !memcmp(identifier, kPrefsIdentifier, identifierSize))
+	{
+		const GpDisplayDriver_SDL_GL2_Prefs *prefs = static_cast<const GpDisplayDriver_SDL_GL2_Prefs *>(contents);
+		m_isFullScreenDesired = prefs->m_isFullScreen;
+	}
 }
 
-bool GpDisplayDriver_SDL_GL2::SavePrefs(void *context, WritePrefsFunc_t writeFunc)
+bool GpDisplayDriver_SDL_GL2::SavePrefs(void *context, IGpPrefsHandler::WritePrefsFunc_t writeFunc)
 {
-	return true;
+	GpDisplayDriver_SDL_GL2_Prefs prefs;
+	prefs.m_isFullScreen = m_isFullScreenDesired;
+
+	return writeFunc(context, kPrefsIdentifier, strlen(kPrefsIdentifier), &prefs, sizeof(prefs), kPrefsVersion);
 }
 
 void GpDisplayDriver_SDL_GL2::UnlinkSurface(GpDisplayDriverSurface_GL2 *surface, GpDisplayDriverSurface_GL2 *prev, GpDisplayDriverSurface_GL2 *next)
@@ -2408,9 +2398,6 @@ bool GpDisplayDriver_SDL_GL2::InitResources(uint32_t physicalWidth, uint32_t phy
 	if (logger)
 		logger->Printf(IGpLogDriver::Category_Information, "GpDisplayDriver_SDL_GL2::InitResources");
 
-	if ((m_pixelScaleX < 2.0f && m_pixelScaleX > 1.0f) || (m_pixelScaleY < 2.0f && m_pixelScaleY > 1.0f))
-		m_useUpscaleFilter = true;
-
 	CheckGLError(m_gl, logger);
 
 	if (!InitBackBuffer(virtualWidth, virtualHeight))
@@ -2489,23 +2476,27 @@ bool GpDisplayDriver_SDL_GL2::InitResources(uint32_t physicalWidth, uint32_t phy
 	GpComPtr<GpGLShader<GL_VERTEX_SHADER>> drawQuadVertexShader = CreateShader<GL_VERTEX_SHADER>(GpBinarizedShaders::g_drawQuadV_GL2);
 	GpComPtr<GpGLShader<GL_FRAGMENT_SHADER>> drawQuadPaletteFlickerPixelShader = CreateShader<GL_FRAGMENT_SHADER>(GpBinarizedShaders::g_drawQuadPalettePF_GL2);
 	GpComPtr<GpGLShader<GL_FRAGMENT_SHADER>> drawQuadPaletteNoFlickerPixelShader = CreateShader<GL_FRAGMENT_SHADER>(GpBinarizedShaders::g_drawQuadPalettePNF_GL2);
-	//m_drawQuadRGBPixelShader = CreateShader<GL_FRAGMENT_SHADER>(GpBinarizedShaders::g_drawQuadRGBP_GL2);
-	//m_drawQuad15BitPixelShader = CreateShader<GL_FRAGMENT_SHADER>(GpBinarizedShaders::g_drawQuad15BitP_GL2);
+	GpComPtr<GpGLShader<GL_FRAGMENT_SHADER>> drawQuad32FlickerPixelShader = CreateShader<GL_FRAGMENT_SHADER>(GpBinarizedShaders::g_drawQuad32PF_GL2);
+	GpComPtr<GpGLShader<GL_FRAGMENT_SHADER>> drawQuad32NoFlickerPixelShader = CreateShader<GL_FRAGMENT_SHADER>(GpBinarizedShaders::g_drawQuad32PNF_GL2);
 	GpComPtr<GpGLShader<GL_FRAGMENT_SHADER>> drawQuadPaletteICCFPixelShader = CreateShader<GL_FRAGMENT_SHADER>(GpBinarizedShaders::g_drawQuadPaletteICCPF_GL2);
 	GpComPtr<GpGLShader<GL_FRAGMENT_SHADER>> drawQuadPaletteICCNFPixelShader = CreateShader<GL_FRAGMENT_SHADER>(GpBinarizedShaders::g_drawQuadPaletteICCPNF_GL2);
-	//m_drawQuadRGBICCPixelShader = CreateShader<GL_FRAGMENT_SHADER>(GpBinarizedShaders::g_drawQuadRGBICCP_GL2);
-	//m_drawQuad15BitICCPixelShader = CreateShader<GL_FRAGMENT_SHADER>(GpBinarizedShaders::g_drawQuad15BitICCP_GL2);
+	GpComPtr<GpGLShader<GL_FRAGMENT_SHADER>> drawQuad32ICCFPixelShader = CreateShader<GL_FRAGMENT_SHADER>(GpBinarizedShaders::g_drawQuad32ICCPF_GL2);
+	GpComPtr<GpGLShader<GL_FRAGMENT_SHADER>> drawQuad32ICCNFPixelShader = CreateShader<GL_FRAGMENT_SHADER>(GpBinarizedShaders::g_drawQuad32ICCPNF_GL2);
 	GpComPtr<GpGLShader<GL_FRAGMENT_SHADER>> scaleQuadPixelShader = CreateShader<GL_FRAGMENT_SHADER>(GpBinarizedShaders::g_scaleQuadP_GL2);
 	GpComPtr<GpGLShader<GL_FRAGMENT_SHADER>> copyQuadPixelShader = CreateShader<GL_FRAGMENT_SHADER>(GpBinarizedShaders::g_copyQuadP_GL2);
 
-	if (!m_res.m_drawQuadPaletteFlickerProgram.Link(this, drawQuadVertexShader, drawQuadPaletteFlickerPixelShader)
-		|| !m_res.m_drawQuadPaletteNoFlickerProgram.Link(this, drawQuadVertexShader, drawQuadPaletteFlickerPixelShader)
-		//|| !m_drawQuadRGBProgram.Link(this, drawQuadVertexShader, drawQuadRGBPixelShader)
-		//|| !m_drawQuad15BitProgram.Link(this, drawQuadVertexShader, drawQuad15BitPixelShader)
+		
+	if (!m_res.m_drawQuadPaletteFlickerProgram.Link(this, drawQuadVertexShader, drawQuadPaletteFlickerPixelShader) ||
+		!m_res.m_drawQuadPaletteNoFlickerProgram.Link(this, drawQuadVertexShader, drawQuadPaletteNoFlickerPixelShader)
+		|| !m_res.m_drawQuad32FlickerProgram.Link(this, drawQuadVertexShader, drawQuad32FlickerPixelShader)
+		|| !m_res.m_drawQuad32NoFlickerProgram.Link(this, drawQuadVertexShader, drawQuad32NoFlickerPixelShader)
 		|| !m_res.m_drawQuadPaletteICCFlickerProgram.Link(this, drawQuadVertexShader, drawQuadPaletteICCFPixelShader)
 		|| !m_res.m_drawQuadPaletteICCNoFlickerProgram.Link(this, drawQuadVertexShader, drawQuadPaletteICCNFPixelShader)
-		//|| !m_drawQuadRGBICCProgram.Link(this, drawQuadVertexShader, drawQuadRGBICCPixelShader)
-		//|| !m_drawQuad15BitICCProgram.Link(this, drawQuadVertexShader, drawQuad15BitICCPixelShader)
+		|| !m_res.m_drawQuad32ICCFlickerProgram.Link(this, drawQuadVertexShader, drawQuad32ICCFPixelShader)
+		|| !m_res.m_drawQuad32ICCNoFlickerProgram.Link(this, drawQuadVertexShader, drawQuad32ICCNFPixelShader)
+
+//		|| !m_drawQuadRGBICCProgram.Link(this, drawQuadVertexShader, drawQuadRGBICCPixelShader)
+//		|| !m_drawQuad15BitICCProgram.Link(this, drawQuadVertexShader, drawQuad15BitICCPixelShader)
 		|| !m_res.m_scaleQuadProgram.Link(this, drawQuadVertexShader, scaleQuadPixelShader)
 		|| !m_res.m_copyQuadProgram.Link(this, drawQuadVertexShader, copyQuadPixelShader))
 		return false;
@@ -2720,8 +2711,9 @@ bool GpDisplayDriver_SDL_GL2::InitBackBuffer(uint32_t width, uint32_t height)
 		m_gl.BindFramebuffer(GL_FRAMEBUFFER, 0);
 	}
 
+	m_useUpscaleFilter = (m_pixelScaleX == 1.5f || m_pixelScaleX == 2.5f || m_pixelScaleY == 1.5f || m_pixelScaleY == 2.5f);
 
-	if (m_pixelScaleX != floor(m_pixelScaleX) || m_pixelScaleY != floor(m_pixelScaleY))
+	if (m_useUpscaleFilter)
 	{
 		uint32_t upscaleX = ceil(m_pixelScaleX);
 		uint32_t upscaleY = ceil(m_pixelScaleY);
@@ -2736,8 +2728,8 @@ bool GpDisplayDriver_SDL_GL2::InitBackBuffer(uint32_t width, uint32_t height)
 				return false;
 			}
 
-			m_res.m_upscaleTextureWidth = width * upscaleX;
-			m_res.m_upscaleTextureHeight = height * upscaleY;
+			m_upscaleTextureWidth = width * upscaleX;
+			m_upscaleTextureHeight = height * upscaleY;
 
 			GLenum internalFormat = SupportsSizedFormats() ? GL_RGBA8 : GL_RGBA;
 
@@ -2747,7 +2739,7 @@ bool GpDisplayDriver_SDL_GL2::InitBackBuffer(uint32_t width, uint32_t height)
 			m_gl.TexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
 			m_gl.TexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
 			m_gl.TexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
-			m_gl.TexImage2D(GL_TEXTURE_2D, 0, internalFormat, m_res.m_upscaleTextureWidth, m_res.m_upscaleTextureHeight, 0, GL_RGBA, GL_UNSIGNED_BYTE, nullptr);
+			m_gl.TexImage2D(GL_TEXTURE_2D, 0, internalFormat, m_upscaleTextureWidth, m_upscaleTextureHeight, 0, GL_RGBA, GL_UNSIGNED_BYTE, nullptr);
 			m_gl.BindTexture(GL_TEXTURE_2D, 0);
 
 			CheckGLError(m_gl, logger);
@@ -2792,7 +2784,7 @@ void GpDisplayDriver_SDL_GL2::ScaleVirtualScreen()
 	{
 		m_gl.BindFramebuffer(GL_FRAMEBUFFER, m_res.m_upscaleTextureRTV->GetID());
 
-		m_gl.Viewport(0, 0, m_res.m_upscaleTextureWidth, m_res.m_upscaleTextureHeight);
+		m_gl.Viewport(0, 0, m_upscaleTextureWidth, m_upscaleTextureHeight);
 
 		const BlitQuadProgram &program = m_res.m_scaleQuadProgram;
 
@@ -2998,8 +2990,15 @@ bool GpDisplayDriver_SDL_GL2::BlitQuadProgram::Link(GpDisplayDriver_SDL_GL2 *dri
 	return true;
 }
 
-GpDisplayDriverTickStatus_t GpDisplayDriver_SDL_GL2::PresentFrameAndSync()
+bool GpDisplayDriver_SDL_GL2::SyncRender()
 {
+	if (m_frameTimeAccumulated >= m_frameTimeSliceSize)
+	{
+		m_frameTimeAccumulated -= m_frameTimeSliceSize;
+
+		return true;
+	}
+
 	SynchronizeCursors();
 
 	float bgColor[4];
@@ -3031,6 +3030,10 @@ GpDisplayDriverTickStatus_t GpDisplayDriver_SDL_GL2::PresentFrameAndSync()
 
 	SDL_GL_SwapWindow(m_window);
 
+#ifdef __EMSCRIPTEN__
+	emscripten_sleep(1);
+#endif
+
 	std::chrono::time_point<std::chrono::high_resolution_clock>::duration syncTime = std::chrono::high_resolution_clock::now().time_since_epoch();
 	const intmax_t periodNum = std::chrono::high_resolution_clock::period::num;
 	const intmax_t periodDen = std::chrono::high_resolution_clock::period::den;
@@ -3121,22 +3124,9 @@ GpDisplayDriverTickStatus_t GpDisplayDriver_SDL_GL2::PresentFrameAndSync()
 		}
 
 		m_frameTimeAccumulated += frameTimeStep;
-		while (m_frameTimeAccumulated >= m_frameTimeSliceSize)
-		{
-			GpDisplayDriverTickStatus_t tickStatus = m_properties.m_tickFunc(m_properties.m_tickFuncContext, m_vosFiber);
-			m_frameTimeAccumulated -= m_frameTimeSliceSize;
-
-			if (tickStatus == GpDisplayDriverTickStatuses::kSynchronizing)
-			{
-				m_frameTimeAccumulated = std::chrono::high_resolution_clock::duration::zero();
-				break;
-			}
-			else if (tickStatus != GpDisplayDriverTickStatuses::kOK)
-				return tickStatus;
-		}
 	}
 
-	return GpDisplayDriverTickStatuses::kOK;
+	return false;
 }
 
 IGpDisplayDriver *GpDriver_CreateDisplayDriver_SDL_GL2(const GpDisplayDriverProperties &properties)
@@ -3145,18 +3135,9 @@ IGpDisplayDriver *GpDriver_CreateDisplayDriver_SDL_GL2(const GpDisplayDriverProp
 	if (!driver)
 		return nullptr;
 
-	new (driver) GpDisplayDriver_SDL_GL2(properties);
-
-	if (!driver->Init())
-	{
-		driver->Shutdown();
-		return nullptr;
-	}
-
-	return driver;
+	return new (driver) GpDisplayDriver_SDL_GL2(properties);
 }
 
-
 template<class T>
 T *GpGLObjectImpl<T>::Create(GpDisplayDriver_SDL_GL2 *driver)
 {
@@ -3177,4 +3158,33 @@ T *GpGLObjectImpl<T>::Create(GpDisplayDriver_SDL_GL2 *driver)
 	return obj;
 }
 
+#if GP_ASYNCIFY_PARANOID
+bool IGpDisplayDriver::Init()
+{
+	return static_cast<GpDisplayDriver_SDL_GL2*>(this)->Init();
+}
+
+void IGpDisplayDriver::ServeTicks(int tickCount)
+{
+	static_cast<GpDisplayDriver_SDL_GL2*>(this)->ServeTicks(tickCount);
+}
+
+void IGpDisplayDriver::Shutdown()
+{
+	static_cast<GpDisplayDriver_SDL_GL2*>(this)->Shutdown();
+}
+
+IGpCursor *IGpDisplayDriver::CreateBWCursor(size_t width, size_t height, const void *pixelData, const void *maskData, size_t hotSpotX, size_t hotSpotY)
+{
+	return static_cast<GpDisplayDriver_SDL_GL2*>(this)->CreateBWCursor(width, height, pixelData, maskData, hotSpotX, hotSpotY);
+}
+
+IGpCursor *IGpDisplayDriver::CreateColorCursor(size_t width, size_t height, const void *pixelDataRGBA, size_t hotSpotX, size_t hotSpotY)
+{
+	return static_cast<GpDisplayDriver_SDL_GL2*>(this)->CreateColorCursor(width, height, pixelDataRGBA, hotSpotX, hotSpotY);
+}
+
+#endif
+
+
 #pragma pop_macro("LoadCursor")

AerofoilSDL/GpFiberStarter_SDL.cpp

@@ -1,70 +0,0 @@
-#include "GpFiberStarter.h"
-#include "GpFiber_SDL.h"
-
-#include "HostSystemServices.h"
-#include "HostThreadEvent.h"
-
-#include "SDL_thread.h"
-
-#include <assert.h>
-
-namespace GpFiberStarter_SDL
-{
-	struct FiberStartState
-	{
-		GpFiberStarter::ThreadFunc_t m_threadFunc;
-		PortabilityLayer::HostThreadEvent *m_creatingReturnEvent;
-		PortabilityLayer::HostThreadEvent *m_creatingWakeEvent;
-		void *m_context;
-	};
-
-	static int SDLCALL FiberStartRoutine(void *lpThreadParameter)
-	{
-		const FiberStartState *tss = static_cast<const FiberStartState*>(lpThreadParameter);
-
-		GpFiberStarter::ThreadFunc_t threadFunc = tss->m_threadFunc;
-		PortabilityLayer::HostThreadEvent *creatingReturnEvent = tss->m_creatingReturnEvent;
-		PortabilityLayer::HostThreadEvent *wakeEvent = tss->m_creatingWakeEvent;
-		void *context = tss->m_context;
-		creatingReturnEvent->Signal();
-
-		wakeEvent->Wait();
-
-		threadFunc(context);
-
-		return 0;
-	}
-}
-
-IGpFiber *GpFiberStarter::StartFiber(PortabilityLayer::HostSystemServices *systemServices, ThreadFunc_t threadFunc, void *context, IGpFiber *creatingFiber)
-{
-	PortabilityLayer::HostThreadEvent *returnEvent = systemServices->CreateThreadEvent(true, false);
-	if (!returnEvent)
-		return nullptr;
-
-	PortabilityLayer::HostThreadEvent *wakeEvent = systemServices->CreateThreadEvent(true, false);
-	if (!wakeEvent)
-	{
-		returnEvent->Destroy();
-		return nullptr;
-	}
-
-	GpFiberStarter_SDL::FiberStartState startState;
-	startState.m_context = context;
-	startState.m_creatingReturnEvent = returnEvent;
-	startState.m_creatingWakeEvent = wakeEvent;
-	startState.m_threadFunc = threadFunc;
-
-	SDL_Thread *thread = SDL_CreateThread(GpFiberStarter_SDL::FiberStartRoutine, "Fiber", &startState);
-	if (!thread)
-	{
-		returnEvent->Destroy();
-		wakeEvent->Destroy();
-		return nullptr;
-	}
-
-	returnEvent->Wait();
-	returnEvent->Destroy();
-
-	return new GpFiber_SDL(thread, wakeEvent);
-}

AerofoilSDL/GpFiber_SDL.cpp

@@ -1,30 +0,0 @@
-#include "GpFiber_SDL.h"
-#include "HostSystemServices.h"
-#include "HostThreadEvent.h"
-
-GpFiber_SDL::GpFiber_SDL(SDL_Thread *thread, PortabilityLayer::HostThreadEvent *threadEvent)
-	: m_event(threadEvent)
-	, m_thread(thread)
-{
-}
-
-GpFiber_SDL::~GpFiber_SDL()
-{
-	m_event->Destroy();
-}
-
-void GpFiber_SDL::YieldTo(IGpFiber *toFiber)
-{
-	static_cast<GpFiber_SDL*>(toFiber)->m_event->Signal();
-	m_event->Wait();
-}
-
-void GpFiber_SDL::YieldToTerminal(IGpFiber *toFiber)
-{
-	static_cast<GpFiber_SDL*>(toFiber)->m_event->Signal();
-}
-
-void GpFiber_SDL::Destroy()
-{
-	delete this;
-}

AerofoilSDL/GpFiber_SDL.h

@@ -1,28 +0,0 @@
-#pragma once
-
-#include "IGpFiber.h"
-#include "SDL_thread.h"
-
-namespace PortabilityLayer
-{
-	class HostSystemServices;
-	class HostThreadEvent;
-}
-
-class GpFiber_SDL final : public IGpFiber
-{
-public:
-	explicit GpFiber_SDL(SDL_Thread *thread, PortabilityLayer::HostThreadEvent *threadEvent);
-	~GpFiber_SDL();
-
-	void YieldTo(IGpFiber *fromFiber) override;
-	void YieldToTerminal(IGpFiber *fromFiber) override;
-	void Destroy() override;
-
-private:
-	static int SDLCALL InternalThreadFunction(void *data);
-
-	bool m_isDestroying;
-	PortabilityLayer::HostThreadEvent *m_event;
-	SDL_Thread *m_thread;
-};

AerofoilSDL/GpInputDriver_SDL_Gamepad.cpp

@@ -0,0 +1,308 @@
+#include "GpInputDriver_SDL_Gamepad.h"
+#include "GpVOSEvent.h"
+#include "IGpVOSEventQueue.h"
+
+#include "SDL_events.h"
+#include "SDL_joystick.h"
+#include "SDL_gamecontroller.h"
+
+#include <stdlib.h>
+#include <algorithm>
+#include <new>
+#include <vector>
+
+class GpInputDriverSDLGamepad final : public IGpInputDriverSDLGamepad
+{
+public:
+	void ProcessInput() override;
+	void Shutdown() override;
+
+	IGpPrefsHandler *GetPrefsHandler() const override;
+
+	static GpInputDriverSDLGamepad *Create(const GpInputDriverProperties &props);
+
+	void ProcessSDLEvent(const SDL_Event &evt) override;
+
+private:
+	static const int kMaxPlayers = 2;
+
+	GpInputDriverSDLGamepad(const GpInputDriverProperties &props);
+	~GpInputDriverSDLGamepad();
+
+	bool FindJoystickPlayer(uint8_t &playerNum, SDL_JoystickID joystickID);
+
+	void HandleDeviceAdded(SDL_JoystickID joystickID);
+	void HandleDeviceRemoved(SDL_JoystickID joystickID);
+
+	std::vector<GpVOSEvent> m_pendingEvents;
+
+	GpInputDriverProperties m_properties;
+
+	SDL_JoystickID m_playerJoystickIDs[kMaxPlayers];
+	SDL_GameController *m_playerControllers[kMaxPlayers];
+	bool m_playerButtonDown[kMaxPlayers][GpGamepadButtons::kCount];
+};
+
+static GpInputDriverSDLGamepad *gs_instance = nullptr;
+
+IGpInputDriverSDLGamepad *IGpInputDriverSDLGamepad::GetInstance()
+{
+	return gs_instance;
+}
+
+void GpInputDriverSDLGamepad::ProcessInput()
+{
+	for (size_t i = 0; i < m_pendingEvents.size(); i++)
+	{
+		if (GpVOSEvent *evt = m_properties.m_eventQueue->QueueEvent())
+			*evt = m_pendingEvents[i];
+	}
+
+	m_pendingEvents.clear();
+}
+
+void GpInputDriverSDLGamepad::Shutdown()
+{
+	this->~GpInputDriverSDLGamepad();
+	free(this);
+
+	gs_instance = nullptr;
+}
+
+IGpPrefsHandler *GpInputDriverSDLGamepad::GetPrefsHandler() const
+{
+	return nullptr;
+}
+
+GpInputDriverSDLGamepad *GpInputDriverSDLGamepad::Create(const GpInputDriverProperties &props)
+{
+	void *storage = malloc(sizeof(GpInputDriverSDLGamepad));
+	if (!storage)
+		return nullptr;
+
+	GpInputDriverSDLGamepad *driver = new (storage) GpInputDriverSDLGamepad(props);
+	gs_instance = driver;
+	return driver;
+}
+
+GpInputDriverSDLGamepad::GpInputDriverSDLGamepad(const GpInputDriverProperties &props)
+	: m_properties(props)
+{
+	for (int i = 0; i < kMaxPlayers; i++)
+	{
+		m_playerJoystickIDs[i] = -1;
+		m_playerControllers[i] = nullptr;
+
+		for (int j = 0; j < GpGamepadButtons::kCount; j++)
+			m_playerButtonDown[i][j] = false;
+	}
+}
+
+GpInputDriverSDLGamepad::~GpInputDriverSDLGamepad()
+{
+	for (int i = 0; i < kMaxPlayers; i++)
+	{
+		if (m_playerControllers[i])
+			SDL_GameControllerClose(m_playerControllers[i]);
+	}
+}
+
+bool GpInputDriverSDLGamepad::FindJoystickPlayer(uint8_t &playerNum, SDL_JoystickID joystickID)
+{
+	for (int i = 0; i < kMaxPlayers; i++)
+	{
+		if (m_playerJoystickIDs[i] == joystickID)
+		{
+			playerNum = static_cast<uint8_t>(i);
+			return true;
+		}
+	}
+
+	return false;
+}
+
+void GpInputDriverSDLGamepad::HandleDeviceAdded(SDL_JoystickID joystickID)
+{
+	for (int i = 0; i < kMaxPlayers; i++)
+	{
+		if (m_playerJoystickIDs[i] == -1)
+		{
+			SDL_GameController *controller = SDL_GameControllerOpen(joystickID);
+			if (controller)
+			{
+				m_playerJoystickIDs[i] = joystickID;
+				m_playerControllers[i] = controller;
+			}
+			return;
+		}
+	}
+}
+
+void GpInputDriverSDLGamepad::HandleDeviceRemoved(SDL_JoystickID joystickID)
+{
+	int playerNum = 0;
+	bool foundPlayer = false;
+	for (int i = 0; i < kMaxPlayers; i++)
+	{
+		if (m_playerJoystickIDs[i] == joystickID)
+		{
+			SDL_GameControllerClose(m_playerControllers[i]);
+
+			m_playerJoystickIDs[i] = -1;
+			m_playerControllers[i] = nullptr;
+
+			playerNum = i;
+			foundPlayer = true;
+		}
+	}
+
+	if (!foundPlayer)
+		return;
+
+	for (int axis = 0; axis < GpGamepadAxes::kCount; axis++)
+	{
+		GpVOSEvent evt;
+		evt.m_eventType = GpVOSEventTypes::kGamepadInput;
+		evt.m_event.m_gamepadInputEvent.m_eventType = GpGamepadInputEventTypes::kAnalogAxisChanged;
+		evt.m_event.m_gamepadInputEvent.m_event.m_analogAxisEvent.m_axis = static_cast<GpGamepadAxis_t>(axis);
+		evt.m_event.m_gamepadInputEvent.m_event.m_analogAxisEvent.m_player = playerNum;
+		evt.m_event.m_gamepadInputEvent.m_event.m_analogAxisEvent.m_state = 0;
+
+		m_pendingEvents.push_back(evt);
+	}
+
+	for (int button = 0; button < GpGamepadButtons::kCount; button++)
+	{
+		if (m_playerButtonDown[playerNum][button])
+		{
+			m_playerButtonDown[playerNum][button] = false;
+
+
+
+			GpVOSEvent evt;
+			evt.m_eventType = GpVOSEventTypes::kKeyboardInput;
+			evt.m_event.m_keyboardInputEvent.m_eventType = GpKeyboardInputEventTypes::kUp;
+			evt.m_event.m_keyboardInputEvent.m_keyIDSubset = GpKeyIDSubsets::kGamepadButton;
+			evt.m_event.m_keyboardInputEvent.m_key.m_gamepadKey.m_player = playerNum;
+			evt.m_event.m_keyboardInputEvent.m_key.m_gamepadKey.m_button = static_cast<GpGamepadButton_t>(button);
+			evt.m_event.m_keyboardInputEvent.m_repeatCount = 0;
+
+			m_pendingEvents.push_back(evt);
+		}
+	}
+}
+
+void GpInputDriverSDLGamepad::ProcessSDLEvent(const SDL_Event &msg)
+{
+	IGpVOSEventQueue *evtQueue = m_properties.m_eventQueue;
+
+	switch (msg.type)
+	{
+	case SDL_CONTROLLERAXISMOTION:
+		{
+			const SDL_ControllerAxisEvent &axisMsg = msg.caxis;
+			GpGamepadAxis_t axis = GpGamepadAxes::kCount;
+
+			uint8_t playerNumber = 0;
+			if (!FindJoystickPlayer(playerNumber, axisMsg.which))
+				break;
+
+			if (axisMsg.axis == SDL_CONTROLLER_AXIS_TRIGGERLEFT)
+				axis = GpGamepadAxes::kLeftTrigger;
+			else if (axisMsg.axis == SDL_CONTROLLER_AXIS_TRIGGERRIGHT)
+				axis = GpGamepadAxes::kRightTrigger;
+			else if (axisMsg.axis == SDL_CONTROLLER_AXIS_LEFTX)
+				axis = GpGamepadAxes::kLeftStickX;
+			else if (axisMsg.axis == SDL_CONTROLLER_AXIS_LEFTY)
+				axis = GpGamepadAxes::kLeftStickY;
+			else if (axisMsg.axis == SDL_CONTROLLER_AXIS_RIGHTX)
+				axis = GpGamepadAxes::kRightStickX;
+			else if (axisMsg.axis == SDL_CONTROLLER_AXIS_RIGHTY)
+				axis = GpGamepadAxes::kRightStickY;
+			else
+				break;
+
+			GpVOSEvent evt;
+			evt.m_eventType = GpVOSEventTypes::kGamepadInput;
+			evt.m_event.m_gamepadInputEvent.m_eventType = GpGamepadInputEventTypes::kAnalogAxisChanged;
+			evt.m_event.m_gamepadInputEvent.m_event.m_analogAxisEvent.m_axis = axis;
+			evt.m_event.m_gamepadInputEvent.m_event.m_analogAxisEvent.m_player = playerNumber;
+			evt.m_event.m_gamepadInputEvent.m_event.m_analogAxisEvent.m_state = std::max<int16_t>(-32767, axisMsg.value);
+
+			m_pendingEvents.push_back(evt);
+		}
+		break;
+	case SDL_CONTROLLERBUTTONDOWN:
+	case SDL_CONTROLLERBUTTONUP:
+		{
+			const bool isDown = (msg.type == SDL_CONTROLLERBUTTONDOWN);
+			const SDL_ControllerButtonEvent &buttonMsg = msg.cbutton;
+
+			GpGamepadButton_t gpButton = GpGamepadButtons::kCount;
+
+			uint8_t playerNumber = 0;
+			if (!FindJoystickPlayer(playerNumber, buttonMsg.which))
+				break;
+
+			if (buttonMsg.button == SDL_CONTROLLER_BUTTON_A)
+				gpButton = GpGamepadButtons::kFaceRight;
+			else if (buttonMsg.button == SDL_CONTROLLER_BUTTON_B)
+				gpButton = GpGamepadButtons::kFaceDown;
+			else if (buttonMsg.button == SDL_CONTROLLER_BUTTON_X)
+				gpButton = GpGamepadButtons::kFaceUp;
+			else if (buttonMsg.button == SDL_CONTROLLER_BUTTON_Y)
+				gpButton = GpGamepadButtons::kFaceLeft;
+			else if (buttonMsg.button == SDL_CONTROLLER_BUTTON_START)
+				gpButton = GpGamepadButtons::kMisc1;
+			else if (buttonMsg.button == SDL_CONTROLLER_BUTTON_BACK)
+				gpButton = GpGamepadButtons::kMisc2;
+			else if (buttonMsg.button == SDL_CONTROLLER_BUTTON_LEFTSTICK)
+				gpButton = GpGamepadButtons::kLeftStick;
+			else if (buttonMsg.button == SDL_CONTROLLER_BUTTON_RIGHTSTICK)
+				gpButton = GpGamepadButtons::kRightStick;
+			else if (buttonMsg.button == SDL_CONTROLLER_BUTTON_LEFTSHOULDER)
+				gpButton = GpGamepadButtons::kLeftBumper;
+			else if (buttonMsg.button == SDL_CONTROLLER_BUTTON_RIGHTSHOULDER)
+				gpButton = GpGamepadButtons::kRightBumper;
+			else if (buttonMsg.button == SDL_CONTROLLER_BUTTON_DPAD_UP)
+				gpButton = GpGamepadButtons::kDPadUp;
+			else if (buttonMsg.button == SDL_CONTROLLER_BUTTON_DPAD_DOWN)
+				gpButton = GpGamepadButtons::kDPadDown;
+			else if (buttonMsg.button == SDL_CONTROLLER_BUTTON_DPAD_LEFT)
+				gpButton = GpGamepadButtons::kDPadLeft;
+			else if (buttonMsg.button == SDL_CONTROLLER_BUTTON_DPAD_RIGHT)
+				gpButton = GpGamepadButtons::kDPadRight;
+			else
+				break;
+
+			m_playerButtonDown[playerNumber][gpButton] = isDown;
+
+			GpVOSEvent evt;
+			evt.m_eventType = GpVOSEventTypes::kKeyboardInput;
+			evt.m_event.m_keyboardInputEvent.m_eventType = (isDown ? GpKeyboardInputEventTypes::kDown : GpKeyboardInputEventTypes::kUp);
+			evt.m_event.m_keyboardInputEvent.m_keyIDSubset = GpKeyIDSubsets::kGamepadButton;
+			evt.m_event.m_keyboardInputEvent.m_key.m_gamepadKey.m_player = playerNumber;
+			evt.m_event.m_keyboardInputEvent.m_key.m_gamepadKey.m_button = gpButton;
+			evt.m_event.m_keyboardInputEvent.m_repeatCount = 0;
+
+			m_pendingEvents.push_back(evt);
+		}
+		break;
+	case SDL_CONTROLLERDEVICEADDED:
+		HandleDeviceAdded(msg.cdevice.which);
+		break;
+	case SDL_CONTROLLERDEVICEREMOVED:
+		HandleDeviceRemoved(msg.cdevice.which);
+		break;
+	case SDL_CONTROLLERDEVICEREMAPPED:
+		// Not really sure what to do here, just re-add it
+		HandleDeviceRemoved(msg.cdevice.which);
+		HandleDeviceAdded(msg.cdevice.which);
+		break;
+	}
+}
+
+IGpInputDriver *GpDriver_CreateInputDriver_SDL2_Gamepad(const GpInputDriverProperties &properties)
+{
+	return GpInputDriverSDLGamepad::Create(properties);
+}

AerofoilSDL/GpInputDriver_SDL_Gamepad.h

@@ -0,0 +1,14 @@
+#pragma once
+
+#include "IGpInputDriver.h"
+#include "GpInputDriverProperties.h"
+#include "GpVOSEvent.h"
+
+union SDL_Event;
+
+struct IGpInputDriverSDLGamepad : public IGpInputDriver
+{
+	virtual void ProcessSDLEvent(const SDL_Event &evt) = 0;
+
+	static IGpInputDriverSDLGamepad *GetInstance();
+};

AerofoilSDL/GpMain_SDL_Win32.cpp

@@ -1,11 +1,10 @@
 #include "SDL.h"
 
 #include "GpMain.h"
+#include "GpAllocator_C.h"
 #include "GpAudioDriverFactory.h"
 #include "GpDisplayDriverFactory.h"
 #include "GpGlobalConfig.h"
-#include "GpFiber_Win32.h"
-#include "GpFiber_SDL.h"
 #include "GpFileSystem_Win32.h"
 #include "GpLogDriver_Win32.h"
 #include "GpFontHandlerFactory.h"
@@ -13,10 +12,10 @@
 #include "GpAppInterface.h"
 #include "GpSystemServices_Win32.h"
 #include "GpVOSEvent.h"
-#include "IGpVOSEventQueue.h"
 
-#include "HostFileSystem.h"
-#include "HostThreadEvent.h"
+#include "IGpFileSystem.h"
+#include "IGpThreadEvent.h"
+#include "IGpVOSEventQueue.h"
 
 #include "GpWindows.h"
 
@@ -29,16 +28,22 @@
 
 GpWindowsGlobals g_gpWindowsGlobals;
 
-extern "C" __declspec(dllimport) IGpInputDriver *GpDriver_CreateInputDriver_XInput(const GpInputDriverProperties &properties);
 extern "C" __declspec(dllimport) IGpFontHandler *GpDriver_CreateFontHandler_FreeType2(const GpFontHandlerProperties &properties);
 
 IGpDisplayDriver *GpDriver_CreateDisplayDriver_SDL_GL2(const GpDisplayDriverProperties &properties);
 IGpAudioDriver *GpDriver_CreateAudioDriver_SDL(const GpAudioDriverProperties &properties);
+IGpInputDriver *GpDriver_CreateInputDriver_SDL2_Gamepad(const GpInputDriverProperties &properties);
 
 
 int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow)
 {
-	if (SDL_Init(SDL_INIT_VIDEO) < 0)
+	IGpAllocator *alloc = GpAllocator_C::GetInstance();
+
+	GpFileSystem_Win32 *fs = GpFileSystem_Win32::CreateInstance(alloc);
+	if (!fs)
+		return -1;
+
+	if (SDL_Init(SDL_INIT_VIDEO | SDL_INIT_GAMECONTROLLER) < 0)
 		return -1;
 
 	LPWSTR cmdLine = GetCommandLineW();
@@ -56,10 +61,12 @@ int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine
 	}
 
 	IGpLogDriver *logger = GpLogDriver_Win32::GetInstance();
+	GpDriverCollection *drivers = GpAppInterface_Get()->PL_GetDriverCollection();
 
-	GpAppInterface_Get()->PL_HostFileSystem_SetInstance(GpFileSystem_Win32::GetInstance());
-	GpAppInterface_Get()->PL_HostSystemServices_SetInstance(GpSystemServices_Win32::GetInstance());
-	GpAppInterface_Get()->PL_HostLogDriver_SetInstance(GpLogDriver_Win32::GetInstance());
+	drivers->SetDriver<GpDriverIDs::kFileSystem>(fs);
+	drivers->SetDriver<GpDriverIDs::kSystemServices>(GpSystemServices_Win32::GetInstance());
+	drivers->SetDriver<GpDriverIDs::kLog>(GpLogDriver_Win32::GetInstance());
+	drivers->SetDriver<GpDriverIDs::kAlloc>(GpAllocator_C::GetInstance());
 
 	g_gpWindowsGlobals.m_hInstance = hInstance;
 	g_gpWindowsGlobals.m_hPrevInstance = hPrevInstance;
@@ -78,7 +85,7 @@ int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine
 
 	EGpInputDriverType inputDrivers[] =
 	{
-		EGpInputDriverType_XInput
+		EGpInputDriverType_SDL2_Gamepad
 	};
 
 	g_gpGlobalConfig.m_inputDriverTypes = inputDrivers;
@@ -87,10 +94,11 @@ int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine
 	g_gpGlobalConfig.m_osGlobals = &g_gpWindowsGlobals;
 	g_gpGlobalConfig.m_logger = logger;
 	g_gpGlobalConfig.m_systemServices = GpSystemServices_Win32::GetInstance();
+	g_gpGlobalConfig.m_allocator = alloc;
 
 	GpDisplayDriverFactory::RegisterDisplayDriverFactory(EGpDisplayDriverType_SDL_GL2, GpDriver_CreateDisplayDriver_SDL_GL2);
 	GpAudioDriverFactory::RegisterAudioDriverFactory(EGpAudioDriverType_SDL2, GpDriver_CreateAudioDriver_SDL);
-	GpInputDriverFactory::RegisterInputDriverFactory(EGpInputDriverType_XInput, GpDriver_CreateInputDriver_XInput);
+	GpInputDriverFactory::RegisterInputDriverFactory(EGpInputDriverType_SDL2_Gamepad, GpDriver_CreateInputDriver_SDL2_Gamepad);
 	GpFontHandlerFactory::RegisterFontHandlerFactory(EGpFontHandlerType_FreeType2, GpDriver_CreateFontHandler_FreeType2);
 
 	if (logger)
@@ -103,5 +111,7 @@ int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine
 
 	LocalFree(cmdLineArgs);
 
+	fs->Destroy();
+
 	return returnCode;
 }

AerofoilSDL/GpSDL.h

@@ -0,0 +1,5 @@
+#ifdef __CYGWIN__
+#define GP_SDL_DIRECTORY_PREFIX "SDL2/"
+#else
+#define GP_SDL_DIRECTORY_PREFIX
+#endif

AerofoilSDL/ShaderCode/DrawQuad32P.cpp

@@ -0,0 +1,35 @@
+#include "Functions.h"
+#include "DrawQuadPixelConstants.h"
+
+#define GP_GL_SHADER_CODE_DRAWQUAD32P_GLSL	\
+"\n"\
+"varying vec4 texCoord;\n"\
+"uniform sampler2D surfaceTexture;\n"\
+"uniform sampler2D paletteTexture;\n"\
+"\n"\
+"vec3 SamplePixel(vec2 tc)\n"\
+"{\n"\
+"	return texture2D(surfaceTexture, tc).rgb;\n"\
+"}\n"\
+"\n"\
+"void main()\n"\
+"{\n"\
+"	vec4 resultColor = vec4(SamplePixel(texCoord.xy), 1.0);\n"\
+"	resultColor *= constants_Modulation;\n"\
+"#ifdef ENABLE_FLICKER\n"\
+"	resultColor = ApplyFlicker(constants_FlickerAxis, texCoord.zw, constants_FlickerStartThreshold, constants_FlickerEndThreshold, resultColor);\n"\
+"	if (resultColor.a < 1.0)\n"\
+"		discard;\n"\
+"#endif\n"\
+"	resultColor = ApplyDesaturation(constants_Desaturation, resultColor);\n"\
+"\n"\
+"	gl_FragColor = vec4(ApplyColorSpaceTransform(resultColor.rgb), resultColor.a);\n"\
+"}\n"
+
+namespace GpBinarizedShaders
+{
+	const char *g_drawQuad32PF_GL2 = "#define ENABLE_FLICKER\n" GP_GL_SHADER_CODE_MEDIUM_PRECISION_PREFIX GP_GL_SHADER_CODE_DRAWQUADPIXELCONSTANTS_H GP_GL_SHADER_CODE_FUNCTIONS_H GP_GL_SHADER_CODE_DRAWQUAD32P_GLSL;
+	const char *g_drawQuad32PNF_GL2 = GP_GL_SHADER_CODE_MEDIUM_PRECISION_PREFIX GP_GL_SHADER_CODE_DRAWQUADPIXELCONSTANTS_H GP_GL_SHADER_CODE_FUNCTIONS_H GP_GL_SHADER_CODE_DRAWQUAD32P_GLSL;
+	const char *g_drawQuad32ICCPF_GL2 = "#define USE_ICC_PROFILE\n" "#define ENABLE_FLICKER\n" GP_GL_SHADER_CODE_MEDIUM_PRECISION_PREFIX GP_GL_SHADER_CODE_DRAWQUADPIXELCONSTANTS_H GP_GL_SHADER_CODE_FUNCTIONS_H GP_GL_SHADER_CODE_DRAWQUAD32P_GLSL;
+	const char *g_drawQuad32ICCPNF_GL2 = "#define USE_ICC_PROFILE\n" GP_GL_SHADER_CODE_MEDIUM_PRECISION_PREFIX GP_GL_SHADER_CODE_DRAWQUADPIXELCONSTANTS_H GP_GL_SHADER_CODE_FUNCTIONS_H GP_GL_SHADER_CODE_DRAWQUAD32P_GLSL;
+}

AerofoilSDL/ShaderCode/DrawQuadPaletteP.cpp

@@ -18,7 +18,7 @@
 "	vec4 resultColor = vec4(SamplePixel(texCoord.xy), 1.0);\n"\
 "	resultColor *= constants_Modulation;\n"\
 "#ifdef ENABLE_FLICKER\n"\
-"	resultColor = ApplyFlicker(constants_FlickerAxis, texCoord.zw, constants_FlickerStartThreshold, constants_FlickerEndThreshold, resultColor * constants_Modulation);\n"\
+"	resultColor = ApplyFlicker(constants_FlickerAxis, texCoord.zw, constants_FlickerStartThreshold, constants_FlickerEndThreshold, resultColor);\n"\
 "	if (resultColor.a < 1.0)\n"\
 "		discard;\n"\
 "#endif\n"\

AerofoilSDL/ShaderCode/Functions.h

@@ -1,7 +1,10 @@
-#define GP_GL_SHADER_CODE_MEDIUM_PRECISION_PREFIX	"precision mediump float;\n"\
-
-#define GP_GL_SHADER_CODE_HIGH_PRECISION_PREFIX	"precision highp float;\n"\
-
+#ifdef __MACOS__
+	#define GP_GL_SHADER_CODE_MEDIUM_PRECISION_PREFIX ""
+	#define GP_GL_SHADER_CODE_HIGH_PRECISION_PREFIX	""
+#else
+	#define GP_GL_SHADER_CODE_MEDIUM_PRECISION_PREFIX "precision mediump float;\n"
+	#define GP_GL_SHADER_CODE_HIGH_PRECISION_PREFIX "precision highp float;\n"
+#endif
 
 #define GP_GL_SHADER_CODE_FUNCTIONS_H	"vec3 pow3(vec3 v, float ex)\n"\
 "{\n"\
@@ -58,7 +61,7 @@
 "vec4 ApplyDesaturation(float desaturation, vec4 color)\n"\
 "{\n"\
 "	// This is intentionally done in gamma space\n"\
-"	if (desaturation == 0.0)\n"\
+"	if (desaturation == 0.0 || (color.r == 1.0 && color.g == 1.0 && color.b == 0.0))\n"\
 "		return color;\n"\
 "\n"\
 "	float grayLevel = dot(color.rgb, vec3(3.0, 6.0, 1.0) / 10.0);\n"\

AerofoilWeb/.gitignore

@@ -0,0 +1,3 @@
+obj
+res
+bin

AerofoilWeb/AerofoilWeb_Combined.cpp

@@ -0,0 +1,4 @@
+#include "GpFileSystem_Web.cpp"
+#include "GpLogDriver_Web.cpp"
+#include "GpMain_SDL_Web.cpp"
+#include "GpSystemServices_Web.cpp"

AerofoilWeb/AerofoilWeb_Resources.cpp

@@ -0,0 +1,15 @@
+#include <stdint.h>
+
+#include "GpFileSystem_Web_Resources.h"
+
+namespace GpFileSystem_Web_Resources
+{
+	namespace ApplicationData
+	{
+		#include "res/ApplicationData.h"
+	}
+	namespace GameData
+	{
+		#include "res/GameData.h"
+	}
+}

AerofoilWeb/BuildAerofoilPortable.bat

@@ -0,0 +1,11 @@
+set INPUT_DIR=../AerofoilPortable
+set OUTPUT_DIR=obj
+
+rem set DEBUG_LEVEL_FLAGS=-g4 -O0
+set DEBUG_LEVEL_FLAGS=-O3 -DNDEBUG=1
+
+set FLAGS=-s USE_SDL=2 -flto -I../GpCommon/ -I../Common/ -s ASYNCIFY %DEBUG_LEVEL_FLAGS% -DGP_DEBUG_CONFIG=0
+
+emcc -c %INPUT_DIR%/GpAllocator_C.cpp -o %OUTPUT_DIR%/AerofoilPortable_Combined.o %FLAGS%
+
+pause

AerofoilWeb/BuildAerofoilSDL.bat

@@ -0,0 +1,11 @@
+set INPUT_DIR=../AerofoilSDL
+set OUTPUT_DIR=obj
+
+rem set DEBUG_LEVEL_FLAGS=-g4 -O0
+set DEBUG_LEVEL_FLAGS=-O3 -DNDEBUG=1
+
+set FLAGS=-s USE_SDL=2 -flto -I../GpCommon/ -I../PortabilityLayer/ -I../Common/ -s ASYNCIFY %DEBUG_LEVEL_FLAGS% -DGP_DEBUG_CONFIG=0
+
+emcc -c %INPUT_DIR%/AerofoilSDL_Combined.cpp -o %OUTPUT_DIR%/AerofoilSDL_Combined.o %FLAGS%
+
+pause

AerofoilWeb/BuildAerofoilWeb.bat

@@ -0,0 +1,11 @@
+set INPUT_DIR=.
+set OUTPUT_DIR=obj
+
+rem set DEBUG_LEVEL_FLAGS=-g4 -O0
+set DEBUG_LEVEL_FLAGS=-O3 -DNDEBUG=1
+
+set FLAGS=-s USE_SDL=2 -flto -I../GpCommon/ -I../PortabilityLayer/ -I../Common/ -I../AerofoilPortable/ -I../GpShell/ -s ASYNCIFY %DEBUG_LEVEL_FLAGS% -DGP_DEBUG_CONFIG=0
+
+emcc -c %INPUT_DIR%/AerofoilWeb_Combined.cpp -o %OUTPUT_DIR%/AerofoilWeb_Combined.o %FLAGS%
+
+pause

AerofoilWeb/BuildGpApp.bat

@@ -0,0 +1,11 @@
+set INPUT_DIR=../GpApp
+set OUTPUT_DIR=obj
+
+rem set DEBUG_LEVEL_FLAGS=-g4 -O0
+set DEBUG_LEVEL_FLAGS=-O3 -DNDEBUG=1
+
+set FLAGS=-s USE_SDL=2 -flto -I../GpCommon/ -I../PortabilityLayer/ -I../Common/ -s ASYNCIFY %DEBUG_LEVEL_FLAGS% -DGP_DEBUG_CONFIG=0
+
+emcc -c %INPUT_DIR%/GpApp_Combined.cpp -o %OUTPUT_DIR%/GpApp_Combined.o %FLAGS%
+
+pause

AerofoilWeb/BuildGpShell.bat

@@ -0,0 +1,11 @@
+set INPUT_DIR=../GpShell
+set OUTPUT_DIR=obj
+
+rem set DEBUG_LEVEL_FLAGS=-g4 -O0
+set DEBUG_LEVEL_FLAGS=-O3 -DNDEBUG=1
+
+set FLAGS=-s USE_SDL=2 -flto -I../GpCommon/ -I../PortabilityLayer/ -I../Common/ -s ASYNCIFY %DEBUG_LEVEL_FLAGS% -DGP_DEBUG_CONFIG=0
+
+emcc -c %INPUT_DIR%/GpShell_Combined.cpp -o %OUTPUT_DIR%/GpShell_Combined.o %FLAGS%
+
+pause

AerofoilWeb/BuildMacRomanConversion.bat

@@ -0,0 +1,11 @@
+set INPUT_DIR=../MacRomanConversion
+set OUTPUT_DIR=obj
+
+rem set DEBUG_LEVEL_FLAGS=-g4 -O0
+set DEBUG_LEVEL_FLAGS=-O3 -DNDEBUG=1
+
+set FLAGS=-flto -I../MacRomanConversion/ -s ASYNCIFY %DEBUG_LEVEL_FLAGS%
+
+emcc -c %INPUT_DIR%/MacRomanConversion.cpp -o %OUTPUT_DIR%/MacRomanConversion.o %FLAGS%
+
+pause

AerofoilWeb/BuildPortabilityLayer.bat

@@ -0,0 +1,11 @@
+set INPUT_DIR=../PortabilityLayer
+set OUTPUT_DIR=obj
+
+rem set DEBUG_LEVEL_FLAGS=-g4 -O0
+set DEBUG_LEVEL_FLAGS=-O3 -DNDEBUG=1
+
+set FLAGS=-s USE_ZLIB=1 -flto -I../GpCommon/ -I../Common/ -I../PortabilityLayer/ -I../rapidjson/include/ -I../MacRomanConversion/ -I../stb/ -s ASYNCIFY %DEBUG_LEVEL_FLAGS% -DGP_DEBUG_CONFIG=0 -Wno-tautological-constant-out-of-range-compare
+
+emcc -c %INPUT_DIR%/PortabilityLayer_Combined.cpp -o %OUTPUT_DIR%/PortabilityLayer_Combined.o %FLAGS%
+
+pause

AerofoilWeb/BuildResources.bat

@@ -0,0 +1,10 @@
+..\x64\Release\bin2h.exe ..\Packaged res\ApplicationData.h
+..\x64\Release\bin2h.exe ..\Packaged\Houses res\GameData.h
+
+set INPUT_DIR=.
+set OUTPUT_DIR=obj
+set FLAGS=-flto -O3 -DGP_DEBUG_CONFIG=0
+
+emcc -c %INPUT_DIR%/AerofoilWeb_Resources.cpp -o %OUTPUT_DIR%/AerofoilWeb_Resources.o %FLAGS%
+
+pause

AerofoilWeb/GpFileSystem_Web.cpp

@@ -0,0 +1,867 @@
+#define _LARGEFILE64_SOURCE
+#include "GpFileSystem_Web.h"
+#include "GpIOStream.h"
+#include "IGpDirectoryCursor.h"
+#include "IGpSystemServices.h"
+#include "IGpMutex.h"
+#include "VirtualDirectory.h"
+
+#include "PLDrivers.h"
+
+#include "SDL2/SDL.h"
+#include "SDL2/SDL_rwops.h"
+
+#include <string>
+#include <vector>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <unistd.h>
+#include <errno.h>
+#include <dirent.h>
+#include <emscripten.h>
+
+#include "UTF8.h"
+
+#if defined(__CYGWIN__) || defined(__EMSCRIPTEN__)
+typedef off_t off64_t;
+#define fstat64 fstat
+#define fseek64 fseek
+#define ftruncate64 ftruncate
+#define stat64 stat
+#endif
+
+EM_JS(void, FlushFileSystem, (), {
+	Asyncify.handleSleep(wakeUp => {
+		FS.syncfs(false, function (err) {
+			assert(!err);
+			wakeUp();
+		});
+	});
+});
+
+EM_JS(void, DownloadAndDeleteFile, (const char *fileNamePtr, const char *prettyNamePtr), {
+	var fileName = UTF8ToString(fileNamePtr);
+	var prettyName = UTF8ToString(prettyNamePtr);
+	console.log("Flush download of file " + fileName + " as " + prettyName);
+
+	var mimeType = "application/octet-stream";
+	if (prettyName.endsWith(".bin"))
+		mimeType = "application/macbinary";
+	else if (prettyName.endsWith(".gpf"))
+		mimeType = "application/zip";
+
+	var byteArray = FS.readFile(fileName, { encoding: "binary" });
+	var blob = new Blob([byteArray], { type: mimeType });
+	saveAs(blob, prettyName);
+});
+
+
+class GpDirectoryCursor_Web final : public IGpDirectoryCursor
+{
+public:
+	explicit GpDirectoryCursor_Web(DIR *dir, const std::string &prefix);
+	~GpDirectoryCursor_Web();
+
+	bool GetNext(const char *&outFileName) override;
+	void Destroy() override;
+
+private:
+	DIR *m_dir;
+	std::string m_prefix;
+	std::string m_decodedFileName;
+};
+
+GpDirectoryCursor_Web::GpDirectoryCursor_Web(DIR *dir, const std::string &prefix)
+	: m_dir(dir)
+	, m_prefix(prefix)
+{
+}
+
+GpDirectoryCursor_Web::~GpDirectoryCursor_Web()
+{
+	closedir(m_dir);
+}
+
+bool GpDirectoryCursor_Web::GetNext(const char *&outFileName)
+{
+	const size_t prefixLength = m_prefix.size();
+
+	for (;;)
+	{
+		struct dirent *dir = readdir(m_dir);
+		if (!dir)
+			return false;
+
+		const char *fname = dir->d_name;
+
+		const size_t fnameLen = strlen(fname);
+		if (fnameLen > prefixLength && (prefixLength == 0 || !memcmp(&m_prefix[0], fname, prefixLength)))
+		{
+			const char *encodedResult = fname + prefixLength;
+
+			m_decodedFileName.clear();
+			for (size_t i = 0; encodedResult[i] != 0; i++)
+			{
+				char c = encodedResult[i];
+				if (c == '%')
+				{
+					char highNibble = encodedResult[i + 1];
+					if ((highNibble >= '0' && highNibble <= '9') || (highNibble >= 'a' && highNibble <= 'f') || (highNibble >= 'A' && highNibble <= 'F'))
+					{
+						char lowNibble = encodedResult[i + 2];
+
+						if ((lowNibble >= '0' && lowNibble <= '9') || (lowNibble >= 'a' && lowNibble <= 'f') || (lowNibble >= 'A' && lowNibble <= 'F'))
+						{
+							bool failedNibble = false;
+							char nibbles[2] = { highNibble, lowNibble };
+							int decNibbles[2];
+							for (int ni = 0; ni < 2; ni++)
+							{
+								char nc = nibbles[ni];
+								if (nc >= '0' && nc <= '9')
+									decNibbles[ni] = nc - '0';
+								else if (nc >= 'a' && nc <= 'f')
+									decNibbles[ni] = 0xa + (nc - 'a');
+								else if (nc >= 'A' && nc <= 'F')
+									decNibbles[ni] = 0xa + (nc - 'A');
+								else
+									failedNibble = true;
+							}
+							
+							if (!failedNibble)
+							{
+								c = static_cast<char>((decNibbles[0] << 4) + decNibbles[1]);
+								i += 2;
+							}
+						}
+					}
+				}
+
+				m_decodedFileName += c;
+			}
+			
+			outFileName = m_decodedFileName.c_str();
+			return true;
+		}
+	}
+	return true;
+}
+
+void GpDirectoryCursor_Web::Destroy()
+{
+	delete this;
+}
+
+class GpFileStream_Web_StaticMemFile final : public GpIOStream
+{
+public:
+	GpFileStream_Web_StaticMemFile(const unsigned char *bytes, size_t size);
+	~GpFileStream_Web_StaticMemFile();
+
+	size_t Read(void *bytesOut, size_t size) override;
+	size_t Write(const void *bytes, size_t size) override;
+	bool IsSeekable() const override;
+	bool IsReadOnly() const override;
+	bool IsWriteOnly() const override;
+	bool SeekStart(GpUFilePos_t loc) override;
+	bool SeekCurrent(GpFilePos_t loc) override;
+	bool SeekEnd(GpUFilePos_t loc) override;
+	GpUFilePos_t Size() const override;
+	GpUFilePos_t Tell() const override;
+	void GP_ASYNCIFY_PARANOID_NAMED(Close)() override;
+	void Flush() override;
+
+private:
+	const unsigned char *m_bytes;
+	size_t m_offset;
+	size_t m_size;
+};
+
+GpFileStream_Web_StaticMemFile::GpFileStream_Web_StaticMemFile(const unsigned char *bytes, size_t size)
+	: m_bytes(bytes)
+	, m_size(size)
+	, m_offset(0)
+{
+}
+
+GpFileStream_Web_StaticMemFile::~GpFileStream_Web_StaticMemFile()
+{
+}
+
+size_t GpFileStream_Web_StaticMemFile::Read(void *bytesOut, size_t size)
+{
+	size_t available = m_size - m_offset;
+	size = std::min(size, available);
+	
+	memcpy(bytesOut, m_bytes + m_offset, size);
+	m_offset += size;
+	return size;
+}
+
+size_t GpFileStream_Web_StaticMemFile::Write(const void *bytes, size_t size)
+{
+	return 0;
+}
+
+bool GpFileStream_Web_StaticMemFile::IsSeekable() const
+{
+	return true;
+}
+
+bool GpFileStream_Web_StaticMemFile::IsReadOnly() const
+{
+	return true;
+}
+
+bool GpFileStream_Web_StaticMemFile::IsWriteOnly() const
+{
+	return false;
+}
+
+bool GpFileStream_Web_StaticMemFile::SeekStart(GpUFilePos_t loc)
+{
+	if (loc > m_size)
+		return false;
+
+	m_offset = static_cast<size_t>(loc);
+	return true;
+}
+
+bool GpFileStream_Web_StaticMemFile::SeekCurrent(GpFilePos_t loc)
+{
+	GpFilePos_t minOffset = -static_cast<GpFilePos_t>(m_offset);
+	GpFilePos_t maxOffset = static_cast<GpFilePos_t>(m_size - m_offset);
+	
+	if (loc < minOffset || loc > maxOffset)
+		return false;
+
+	m_offset = static_cast<size_t>(static_cast<GpFilePos_t>(m_offset) + loc);
+	return true;
+}
+
+bool GpFileStream_Web_StaticMemFile::SeekEnd(GpUFilePos_t loc)
+{
+	if (loc > m_size)
+		return false;
+
+	m_offset = m_size - loc;
+	return true;
+}
+
+GpUFilePos_t GpFileStream_Web_StaticMemFile::Size() const
+{
+	return m_size;
+}
+
+GpUFilePos_t GpFileStream_Web_StaticMemFile::Tell() const
+{
+	return m_offset;
+}
+
+void GpFileStream_Web_StaticMemFile::GP_ASYNCIFY_PARANOID_NAMED(Close)()
+{
+	delete this;
+}
+
+void GpFileStream_Web_StaticMemFile::Flush()
+{
+}
+
+
+class GpFileStream_Web_File final : public GpIOStream
+{
+public:
+	GpFileStream_Web_File(FILE *f, const std::string &filePath, const std::string &prettyName, bool readOnly, bool writeOnly, bool synchronizeOnClose, bool isIDB);
+	~GpFileStream_Web_File();
+
+	size_t Read(void *bytesOut, size_t size) override;
+	size_t Write(const void *bytes, size_t size) override;
+	bool IsSeekable() const override;
+	bool IsReadOnly() const override;
+	bool IsWriteOnly() const override;
+	bool SeekStart(GpUFilePos_t loc) override;
+	bool SeekCurrent(GpFilePos_t loc) override;
+	bool SeekEnd(GpUFilePos_t loc) override;
+	GpUFilePos_t Size() const override;
+	GpUFilePos_t Tell() const override;
+	void GP_ASYNCIFY_PARANOID_NAMED(Close)() override;
+	void Flush() override;
+
+private:
+	FILE *m_f;
+	std::string m_filePath;
+	std::string m_prettyName;
+	bool m_seekable;
+	bool m_isReadOnly;
+	bool m_isWriteOnly;
+	bool m_synchronizeOnClose;
+	bool m_isIDB;
+};
+
+
+GpFileStream_Web_File::GpFileStream_Web_File(FILE *f, const std::string &filePath, const std::string &prettyName, bool readOnly, bool writeOnly, bool synchronizeOnClose, bool isIDB)
+	: m_f(f)
+	, m_isReadOnly(readOnly)
+	, m_isWriteOnly(writeOnly)
+	, m_synchronizeOnClose(synchronizeOnClose)
+	, m_isIDB(isIDB)
+	, m_filePath(filePath)
+	, m_prettyName(prettyName)
+{
+	m_seekable = (fseek(m_f, 0, SEEK_CUR) == 0);
+}
+
+GpFileStream_Web_File::~GpFileStream_Web_File()
+{
+	fclose(m_f);
+
+	if (m_synchronizeOnClose)
+	{
+		if (m_isIDB)
+			GpFileSystem_Web::MarkFSStateDirty();
+		else
+			GpFileSystem_Web::SyncDownloadFile(m_filePath, m_prettyName);
+	}
+}
+
+size_t GpFileStream_Web_File::Read(void *bytesOut, size_t size)
+{
+	if (m_isWriteOnly)
+		return 0;
+	return fread(bytesOut, 1, size, m_f);
+}
+
+size_t GpFileStream_Web_File::Write(const void *bytes, size_t size)
+{
+	if (m_isReadOnly)
+		return 0;
+	return fwrite(bytes, 1, size, m_f);
+}
+
+bool GpFileStream_Web_File::IsSeekable() const
+{
+	return m_seekable;
+}
+
+bool GpFileStream_Web_File::IsReadOnly() const
+{
+	return m_isReadOnly;
+}
+
+bool GpFileStream_Web_File::IsWriteOnly() const
+{
+	return m_isWriteOnly;
+}
+
+bool GpFileStream_Web_File::SeekStart(GpUFilePos_t loc)
+{
+	if (!m_seekable)
+		return false;
+
+	fflush(m_f);
+	return fseek64(m_f, static_cast<off64_t>(loc), SEEK_SET) >= 0;
+}
+
+bool GpFileStream_Web_File::SeekCurrent(GpFilePos_t loc)
+{
+	if (!m_seekable)
+		return false;
+
+	fflush(m_f);
+	return fseek64(m_f, static_cast<off64_t>(loc), SEEK_CUR) >= 0;
+}
+
+bool GpFileStream_Web_File::SeekEnd(GpUFilePos_t loc)
+{
+	if (!m_seekable)
+		return false;
+
+	fflush(m_f);
+	return fseek64(m_f, -static_cast<off64_t>(loc), SEEK_END) >= 0;
+}
+
+GpUFilePos_t GpFileStream_Web_File::Size() const
+{
+	fflush(m_f);
+
+	struct stat64 s;
+	if (fstat64(fileno(m_f), &s) < 0)
+		return 0;
+
+	return static_cast<GpUFilePos_t>(s.st_size);
+}
+
+GpUFilePos_t GpFileStream_Web_File::Tell() const
+{
+	return static_cast<GpUFilePos_t>(ftell(m_f));
+}
+
+void GpFileStream_Web_File::GP_ASYNCIFY_PARANOID_NAMED(Close)()
+{
+	this->~GpFileStream_Web_File();
+	free(this);
+}
+
+void GpFileStream_Web_File::Flush()
+{
+	fflush(m_f);
+}
+
+
+bool GpFileSystem_Web::ms_fsStateDirty;
+
+
+bool GpFileSystem_Web::ResolvePath(PortabilityLayer::VirtualDirectory_t virtualDirectory, char const* const* paths, size_t numPaths, bool trailingSlash, std::string &resolution, bool &outIsIDB)
+{
+	const char *pathAppend = nullptr;
+	const std::string *rootPath = nullptr;
+	std::string unsanitized;
+	bool isIDB = false;
+
+	switch (virtualDirectory)
+	{
+	case PortabilityLayer::VirtualDirectories::kApplicationData:
+		unsanitized = std::string("Packaged");
+		break;
+	case PortabilityLayer::VirtualDirectories::kGameData:
+		unsanitized = std::string("Packaged/Houses");
+		break;
+	case PortabilityLayer::VirtualDirectories::kFonts:
+		unsanitized = std::string("Resources");
+		break;
+	case PortabilityLayer::VirtualDirectories::kHighScores:
+		pathAppend = "HighScores";
+		rootPath = &m_prefsPath;
+		isIDB = true;
+		break;
+	case PortabilityLayer::VirtualDirectories::kUserData:
+		pathAppend = "Houses";
+		rootPath = &m_prefsPath;
+		isIDB = true;
+		break;
+	case PortabilityLayer::VirtualDirectories::kUserSaves:
+		pathAppend = "SavedGames";
+		rootPath = &m_prefsPath;
+		isIDB = true;
+		break;
+	case PortabilityLayer::VirtualDirectories::kPrefs:
+		pathAppend = "Prefs";
+		rootPath = &m_prefsPath;
+		isIDB = true;
+		break;
+	case PortabilityLayer::VirtualDirectories::kSourceExport:
+		pathAppend = "Export";
+		rootPath = &m_exportPath;
+		isIDB = false;
+		break;
+	default:
+		return false;
+	};
+
+	if (pathAppend)
+	{
+		unsanitized = pathAppend;
+		
+		for (size_t i = 0; i < numPaths; i++)
+		{
+			unsanitized += "/";
+			unsanitized += paths[i];
+		}
+		
+		if (trailingSlash)
+			unsanitized += "/";
+		
+		std::string sanitized;
+		for (size_t i = 0; i < unsanitized.size(); i++)
+		{
+			char c = unsanitized[i];
+			if ((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || c == '_')
+				sanitized += c;
+			else
+			{
+				const char *nibbles = "0123456789abcdef";
+				char subPath[4];
+				subPath[0] = '%';
+				subPath[1] = nibbles[(c >> 4) & 0xf];
+				subPath[2] = nibbles[c & 0xf];
+				subPath[3] = 0;
+
+				sanitized += subPath;
+			}
+		}
+
+		resolution = (*rootPath) + "/" + sanitized;
+	}
+	else
+	{
+		std::string sanitized = m_basePath + unsanitized;
+		
+		for (size_t i = 0; i < numPaths; i++)
+		{
+			sanitized += "/";
+			sanitized += paths[i];
+		}
+
+		resolution = sanitized;
+	}
+
+	outIsIDB = isIDB;
+	return true;
+}
+
+GpFileSystem_Web::GpFileSystem_Web()
+	: m_delayCallback(nullptr)
+{
+}
+
+GpFileSystem_Web::~GpFileSystem_Web()
+{
+}
+
+void GpFileSystem_Web::Init()
+{
+	m_prefsPath = "/aerofoil";
+	m_exportPath = "/aerofoil_memfs";
+
+	char *baseDir = SDL_GetBasePath();
+	m_basePath = baseDir;
+	SDL_free(baseDir);
+
+	char baseDirSeparator = m_basePath[m_basePath.size() - 1];
+	if (m_basePath.size() >= 4 && m_basePath.substr(m_basePath.size() - 4, 3) == "bin")
+		m_basePath = m_basePath.substr(0, m_basePath.size() - 4) + "lib" + baseDirSeparator + "aerofoil" + baseDirSeparator;
+}
+
+bool GpFileSystem_Web::FileExists(PortabilityLayer::VirtualDirectory_t virtualDirectory, const char *path)
+{
+	if (const GpFileSystem_Web_Resources::FileCatalog *catalog = GetCatalogForVirtualDirectory(virtualDirectory))
+	{
+		for (size_t i = 0; i < catalog->m_numEntries; i++)
+		{
+			const GpFileSystem_Web_Resources::FileCatalogEntry &entry = catalog->m_entries[i];
+			if (!strcmp(path, entry.m_fileName))
+				return true;
+		}
+
+		return false;
+	}
+
+	std::string resolvedPath;
+	bool isIDB = false;
+	if (!ResolvePath(virtualDirectory, &path, 1, false, resolvedPath, isIDB))
+		return false;
+
+	struct stat s;
+	return stat(resolvedPath.c_str(), &s) == 0;
+}
+
+bool GpFileSystem_Web::FileLocked(PortabilityLayer::VirtualDirectory_t virtualDirectory, const char *path, bool &exists)
+{
+	if (const GpFileSystem_Web_Resources::FileCatalog *catalog = GetCatalogForVirtualDirectory(virtualDirectory))
+	{
+		for (size_t i = 0; i < catalog->m_numEntries; i++)
+		{
+			const GpFileSystem_Web_Resources::FileCatalogEntry &entry = catalog->m_entries[i];
+			if (!strcmp(path, entry.m_fileName))
+			{
+				exists = true;
+				return true;
+			}
+		}
+
+		exists = false;
+		return false;
+	}
+
+	std::string resolvedPath;
+	bool isIDB = false;
+	if (!ResolvePath(virtualDirectory, &path, 1, false, resolvedPath, isIDB))
+	{
+		if (exists)
+			exists = false;
+		return false;
+	}
+
+	int permissions = access(resolvedPath.c_str(), W_OK | F_OK);
+	exists = ((permissions & F_OK) != 0);
+	return ((permissions & W_OK) != 0);
+}
+
+GpIOStream *GpFileSystem_Web::OpenFileNested(PortabilityLayer::VirtualDirectory_t virtualDirectory, char const* const* subPaths, size_t numSubPaths, bool writeAccess, GpFileCreationDisposition_t createDisposition)
+{
+	if (numSubPaths == 1)
+	{
+		if (const GpFileSystem_Web_Resources::FileCatalog *catalog = GetCatalogForVirtualDirectory(virtualDirectory))
+		{
+			for (size_t i = 0; i < catalog->m_numEntries; i++)
+			{
+				const GpFileSystem_Web_Resources::FileCatalogEntry &entry = catalog->m_entries[i];
+				if (!strcmp(subPaths[0], entry.m_fileName))
+					return new GpFileStream_Web_StaticMemFile(entry.m_data, entry.m_size);
+			}
+
+			return nullptr;
+		}
+	}
+
+	const char *mode = nullptr;
+	bool canWrite = false;
+	bool needResetPosition = false;
+
+	switch (createDisposition)
+	{
+		case GpFileCreationDispositions::kCreateOrOverwrite:
+			mode = "wb";
+			break;
+		case GpFileCreationDispositions::kCreateNew:
+			mode = "x+b";
+			break;
+		case GpFileCreationDispositions::kCreateOrOpen:
+			mode = "a+b";
+			needResetPosition = true;
+			break;
+		case GpFileCreationDispositions::kOpenExisting:
+			mode = writeAccess ? "r+b" : "rb";
+			break;
+		case GpFileCreationDispositions::kOverwriteExisting:
+			mode = "r+b";
+			break;
+		default:
+			return nullptr;
+	};
+
+	std::string resolvedPath;
+	bool isIDB = false;
+	if (!ResolvePath(virtualDirectory, subPaths, numSubPaths, false, resolvedPath, isIDB))
+		return nullptr;
+
+	void *objStorage = malloc(sizeof(GpFileStream_Web_File));
+	if (!objStorage)
+		return nullptr;
+
+	FILE *f = fopen(resolvedPath.c_str(), mode);
+	if (!f)
+	{
+		free(objStorage);
+		return nullptr;
+	}
+
+	if (needResetPosition)
+		fseek(f, 0, SEEK_SET);
+
+	if (createDisposition == GpFileCreationDispositions::kOverwriteExisting)
+	{
+		if (ftruncate64(fileno(f), 0) < 0)
+		{
+			free(objStorage);
+			fclose(f);
+			return nullptr;
+		}
+	}
+
+	std::string prettyName;
+	if (numSubPaths > 0)
+		prettyName = subPaths[numSubPaths - 1];
+
+	return new (objStorage) GpFileStream_Web_File(f, resolvedPath, prettyName, !writeAccess, false, writeAccess, isIDB);
+}
+
+bool GpFileSystem_Web::DeleteFile(PortabilityLayer::VirtualDirectory_t virtualDirectory, const char *path, bool &existed)
+{
+	if (const GpFileSystem_Web_Resources::FileCatalog *catalog = GetCatalogForVirtualDirectory(virtualDirectory))
+		return false;
+
+	std::string resolvedPath;
+	bool isIDB = false;
+	if (!ResolvePath(virtualDirectory, &path, 1, false, resolvedPath, isIDB))
+	{
+		existed = false;
+		return false;
+	}
+
+	if (unlink(resolvedPath.c_str()) < 0)
+	{
+		existed = (errno != ENOENT);
+		return false;
+	}
+
+	if (isIDB)
+		MarkFSStateDirty();
+
+	existed = true;
+	return true;
+}
+
+bool GpFileSystem_Web::ValidateFilePath(const char *path, size_t length) const
+{
+	for (size_t i = 0; i < length; i++)
+	{
+		const char c = path[i];
+		if (c >= '0' && c <= '9')
+			continue;
+
+		if (c == '_' || c == '.' || c == '\'' || c == '!')
+			continue;
+
+		if (c == ' ' && i != 0 && i != length - 1)
+			continue;
+
+		if (c >= 'a' && c <= 'z')
+			continue;
+
+		if (c >= 'A' && c <= 'Z')
+			continue;
+
+		return false;
+	}
+
+	return true;
+}
+
+bool GpFileSystem_Web::ValidateFilePathUnicodeChar(uint32_t c) const
+{
+	if (c >= '0' && c <= '9')
+		return true;
+
+	if (c == '_' || c == '\'')
+		return true;
+
+	if (c == ' ')
+		return true;
+
+	if (c >= 'a' && c <= 'z')
+		return true;
+
+	if (c >= 'A' && c <= 'Z')
+		return true;
+
+	return false;
+}
+
+void GpFileSystem_Web::SetDelayCallback(DelayCallback_t delayCallback)
+{
+	m_delayCallback = delayCallback;
+}
+
+GpFileSystem_Web *GpFileSystem_Web::GetInstance()
+{
+	return &ms_instance;
+}
+
+class GpDirectoryCursor_StringList final : public IGpDirectoryCursor
+{
+public:
+	explicit GpDirectoryCursor_StringList(std::vector<std::string> &paths);
+	~GpDirectoryCursor_StringList();
+
+	bool GetNext(const char *&outFileName) override;
+	void Destroy() override;
+
+private:
+	std::vector<std::string> m_paths;
+	size_t m_index;
+};
+
+GpDirectoryCursor_StringList::GpDirectoryCursor_StringList(std::vector<std::string> &paths)
+	: m_index(0)
+{
+	std::swap(paths, m_paths);
+}
+
+GpDirectoryCursor_StringList::~GpDirectoryCursor_StringList()
+{
+}
+
+bool GpDirectoryCursor_StringList::GetNext(const char *&outFileName)
+{
+	if (m_index == m_paths.size())
+		return false;
+	outFileName = m_paths[m_index].c_str();
+	m_index++;
+	return true;
+}
+
+void GpDirectoryCursor_StringList::Destroy()
+{
+	delete this;
+}
+
+
+IGpDirectoryCursor *GpFileSystem_Web::ScanDirectoryNested(PortabilityLayer::VirtualDirectory_t virtualDirectory, char const* const* paths, size_t numPaths)
+{
+	if (const GpFileSystem_Web_Resources::FileCatalog *catalog = GetCatalogForVirtualDirectory(virtualDirectory))
+		return ScanCatalog(*catalog);
+
+	std::string resolvedPrefix;
+	bool isIDB = false;
+	if (!ResolvePath(virtualDirectory, paths, numPaths, true, resolvedPrefix, isIDB))
+		return nullptr;
+
+	std::string trimmedPrefix = resolvedPrefix.substr(m_prefsPath.size() + 1);
+
+	DIR *d = opendir(m_prefsPath.c_str());
+	if (!d)
+		return nullptr;
+
+	return new GpDirectoryCursor_Web(d, trimmedPrefix);
+}
+
+const GpFileSystem_Web_Resources::FileCatalog *GpFileSystem_Web::GetCatalogForVirtualDirectory(PortabilityLayer::VirtualDirectory_t virtualDirectory)
+{
+	if (virtualDirectory == PortabilityLayer::VirtualDirectories::kApplicationData)
+		return &GpFileSystem_Web_Resources::ApplicationData::GetCatalog();
+
+	if (virtualDirectory == PortabilityLayer::VirtualDirectories::kGameData)
+		return &GpFileSystem_Web_Resources::GameData::GetCatalog();
+
+	return nullptr;
+}
+
+IGpDirectoryCursor *GpFileSystem_Web::ScanCatalog(const GpFileSystem_Web_Resources::FileCatalog &catalog)
+{
+	std::vector<std::string> paths;
+	for (size_t i = 0; i < catalog.m_numEntries; i++)
+		paths.push_back(std::string(catalog.m_entries[i].m_fileName));
+
+	return new GpDirectoryCursor_StringList(paths);
+}
+
+void GpFileSystem_Web::MarkFSStateDirty()
+{
+	ms_fsStateDirty = true;
+}
+
+void GpFileSystem_Web::SyncDownloadFile(const std::string &filePath, const std::string &prettyName)
+{
+	DownloadAndDeleteFile(filePath.c_str(), prettyName.c_str());
+}
+
+void GpFileSystem_Web::FlushFS()
+{
+	if (ms_fsStateDirty)
+	{
+		ms_fsStateDirty = false;
+		FlushFileSystem();
+	}
+}
+
+
+#if GP_ASYNCIFY_PARANOID
+void GpIOStream::Close()
+{
+	this->GP_ASYNCIFY_PARANOID_NAMED(Close)();
+	GpFileSystem_Web::FlushFS();
+}
+
+bool IGpFileSystem::DeleteFile(PortabilityLayer::VirtualDirectory_t virtualDirectory, const char *path, bool &existed)
+{
+	bool deleted = static_cast<GpFileSystem_Web*>(this)->DeleteFile(virtualDirectory, path, existed);
+	if (deleted)
+		GpFileSystem_Web::FlushFS();
+
+	return deleted;
+}
+
+#endif
+
+GpFileSystem_Web GpFileSystem_Web::ms_instance;

AerofoilWeb/GpFileSystem_Web.h

@@ -0,0 +1,68 @@
+#pragma once
+
+#include "IGpFileSystem.h"
+#include "GpFileSystem_Web_Resources.h"
+
+#include "GpCoreDefs.h"
+
+#include <string>
+#include <stdio.h>
+
+struct IGpMutex;
+
+class GpFileSystem_Web final : public IGpFileSystem
+{
+public:
+	GpFileSystem_Web();
+	~GpFileSystem_Web();
+	
+	void Init();
+
+	bool FileExists(PortabilityLayer::VirtualDirectory_t virtualDirectory, const char *path) override;
+	bool FileLocked(PortabilityLayer::VirtualDirectory_t virtualDirectory, const char *path, bool &exists) override;
+	GpIOStream *OpenFileNested(PortabilityLayer::VirtualDirectory_t virtualDirectory, char const* const* subPaths, size_t numSubPaths, bool writeAccess, GpFileCreationDisposition_t createDisposition) override;
+	bool DeleteFile(PortabilityLayer::VirtualDirectory_t virtualDirectory, const char *path, bool &existed) GP_ASYNCIFY_PARANOID_OVERRIDE;
+	IGpDirectoryCursor *ScanDirectoryNested(PortabilityLayer::VirtualDirectory_t virtualDirectory, char const* const* paths, size_t numPaths) override;
+
+	bool ValidateFilePath(const char *path, size_t pathLen) const override;
+	bool ValidateFilePathUnicodeChar(uint32_t ch) const override;
+
+	void SetDelayCallback(DelayCallback_t delayCallback) override;
+
+	static void MarkFSStateDirty();
+	static void SyncDownloadFile(const std::string &filePath, const std::string &prettyName);
+	static void FlushFS();
+
+	static GpFileSystem_Web *GetInstance();
+
+private:
+	struct ScanDirectoryNestedContext
+	{
+		GpFileSystem_Web *m_this;
+
+		IGpDirectoryCursor *m_returnValue;
+		PortabilityLayer::VirtualDirectory_t m_virtualDirectory;
+		char const *const *m_paths;
+		size_t m_numPaths;
+	};
+
+	static void ScanDirectoryNestedThunk(void *context);
+	IGpDirectoryCursor *ScanDirectoryNestedInternal(PortabilityLayer::VirtualDirectory_t virtualDirectory, char const* const* paths, size_t numPaths);
+
+	IGpDirectoryCursor *ScanDirectory(PortabilityLayer::VirtualDirectory_t virtualDirectory, char const* const* paths, size_t numPaths);
+	
+	static const GpFileSystem_Web_Resources::FileCatalog *GetCatalogForVirtualDirectory(PortabilityLayer::VirtualDirectory_t virtualDirectory);
+
+	static IGpDirectoryCursor *ScanCatalog(const GpFileSystem_Web_Resources::FileCatalog &catalog);
+
+	bool ResolvePath(PortabilityLayer::VirtualDirectory_t virtualDirectory, char const* const* paths, size_t numPaths, bool trailingSlash, std::string &resolution, bool &outIsIDB);
+
+	DelayCallback_t m_delayCallback;
+
+	std::string m_prefsPath;
+	std::string m_basePath;
+	std::string m_exportPath;
+	static bool ms_fsStateDirty;
+
+	static GpFileSystem_Web ms_instance;
+};

AerofoilWeb/GpFileSystem_Web_Resources.h

@@ -0,0 +1,28 @@
+#pragma once
+
+namespace GpFileSystem_Web_Resources
+{
+	struct FileCatalogEntry
+	{
+		const char *m_fileName;
+		const unsigned char *m_data;
+		const unsigned int m_size;
+	};
+	
+	struct FileCatalog
+	{
+		const FileCatalogEntry *m_entries;
+		const unsigned int m_numEntries;
+		const unsigned int m_size;
+		const unsigned int m_size0;
+	};
+	
+	namespace ApplicationData
+	{
+		const FileCatalog &GetCatalog();
+	}
+	namespace GameData
+	{
+		const FileCatalog &GetCatalog();
+	}
+}

AerofoilWeb/GpLogDriver_Web.cpp

@@ -0,0 +1,89 @@
+#include "GpLogDriver_Web.h"
+#include "GpFileSystem_Web.h"
+
+#include "GpApplicationName.h"
+#include "GpIOStream.h"
+
+#include <time.h>
+#include <cstring>
+
+GpLogDriver_Web::GpLogDriver_Web()
+{
+}
+
+void GpLogDriver_Web::Init()
+{
+	ms_instance.InitInternal();
+}
+
+void GpLogDriver_Web::VPrintf(Category category, const char *fmt, va_list args)
+{
+	size_t fmtSize = 0;
+	bool hasFormatting = false;
+	for (const char *fmtCheck = fmt; *fmtCheck; fmtCheck++)
+	{
+		if (*fmtCheck == '%')
+			hasFormatting = true;
+
+		fmtSize++;
+	}
+
+	time_t t = time(nullptr);
+	struct tm sysTime = *localtime(&t);
+
+	char timestampBuffer[64];
+	sprintf(timestampBuffer, "[%02d:%02d:%02d] ", sysTime.tm_hour, sysTime.tm_min, sysTime.tm_sec);
+
+	const char *debugTag = "";
+
+	switch (category)
+	{
+	case Category_Warning:
+		debugTag = "[WARNING] ";
+		break;
+	case Category_Error:
+		debugTag = "[ERROR] ";
+		break;
+	default:
+		break;
+	};
+
+	int formattedSize = vsnprintf(nullptr, 0, fmt, args);
+	if (formattedSize <= 0)
+		return;
+
+	char *charBuff = static_cast<char*>(malloc(formattedSize + 1));
+	if (!charBuff)
+		return;
+
+	vsnprintf(charBuff, formattedSize + 1, fmt, args);
+
+	fprintf(stdout, "%s%s%s\n", timestampBuffer, debugTag, charBuff);
+	fflush(stdout);
+
+	free(charBuff);
+}
+
+void GpLogDriver_Web::Shutdown()
+{
+}
+
+GpLogDriver_Web *GpLogDriver_Web::GetInstance()
+{
+	return &ms_instance;
+}
+
+void GpLogDriver_Web::InitInternal()
+{
+	time_t t = time(nullptr);
+	struct tm utcTime = *gmtime(&t);
+
+	this->Printf(IGpLogDriver::Category_Information, GP_APPLICATION_NAME " build " __TIMESTAMP__);
+#if !GP_DEBUG_CONFIG
+	this->Printf(IGpLogDriver::Category_Information, "Configuration: Release");
+#else
+	this->Printf(IGpLogDriver::Category_Information, "Configuration: Debug");
+#endif
+}
+
+GpLogDriver_Web GpLogDriver_Web::ms_instance;