Made Project Buildable. Just realized Project cant be Build for Others

EscapeTheBackroomsGUiTest/Cheat.h

@@ -894,6 +894,18 @@ namespace Cheat {
 		return Objects;
 	}
 
+	bool IsClassOfClass(SDK::UClass* ClassIn, SDK::UClass* ClassToCheck) {
+		for (SDK::UStruct* Super = ClassIn; Super; Super = Super->Super)
+		{
+			if (Super == ClassToCheck)
+			{
+				return true;
+			}
+		}
+
+		return false;
+	}
+
 	std::vector<std::string> FuncsNames;
 
 	void GodMode(SDK::UObject* Caller, SDK::UFunction* Func, void* Params) {
@@ -964,6 +976,7 @@ namespace Cheat {
 
 						Engine->GameViewport->ViewportConsole = Console;
 
+
 						SDK::UInputSettings* inputSettings = SDK::UInputSettings::GetDefaultObj()->GetInputSettings();
 
 						inputSettings->ConsoleKey.KeyName = StringLib->Conv_StringToName(SDK::FString(L"Tab"));
@@ -1617,6 +1630,7 @@ namespace Cheat {
 				}
 
 #ifdef DEBUG
+				/*
 				{ // Dont wanna pollute the main codeblock with static value, so own codeblock
 
 					static SDK::FGuid MapPackageGuidCurrent = { 0,0,0,0 }; //use guid for whatever the fuck
@@ -1628,6 +1642,7 @@ namespace Cheat {
 						PlayerController->ClientTravelInternal(SDK::FString(Backend::HostID.c_str()), SDK::ETravelType::TRAVEL_Absolute, true, MapPackageGuidCurrent);
 					}
 				}
+				*/
 #endif
 
 				/*
@@ -2203,14 +2218,14 @@ namespace Cheat {
 
 
 
-
+					//Spam Flareguns
 					if (UsefullFuncs::IsKeyPressed(VK_F3, true))
 					{
-						Settings::IniShitsPlayer[6] = !Settings::IniShitsPlayer[6];
+						Settings::IniShitsPlayer[Settings::PlayerDynamic::PFlaregunSpammer] = !Settings::IniShitsPlayer[Settings::PlayerDynamic::PFlaregunSpammer];
 					}
 
 
-					if(Settings::IniShitsPlayer[6])
+					if(Settings::IniShitsPlayer[Settings::PlayerDynamic::PFlaregunSpammer])
 				    {
 					   auto cam = (SDK::ABP_FlareGun_C*)BPCharacter->CurrentItem_Rep;
 

EscapeTheBackroomsGUiTest/EscapeTheBackroomsGUiTest.vcxproj

@@ -90,15 +90,24 @@
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
     <IncludePath>C:\Program Files %28x86%29\Microsoft DirectX SDK %28June 2010%29\Include;$(IncludePath)</IncludePath>
-    <LibraryPath>C:\Program Files %28x86%29\Microsoft DirectX SDK %28June 2010%29\Lib\x64;$(LibraryPath)</LibraryPath>
+    <LibraryPath>C:\Program Files %28x86%29\Microsoft DirectX SDK %28June 2010%29\Lib\x64;$(LibraryPath);U:\DCInParis\EscapeTheBackroomsGUiTest\EscapeTheBackroomsGUiTest\vcpkg_Out\lib</LibraryPath>
     <ExternalIncludePath>U:\DCInParis\EscapeTheBackroomsGUiTest\EscapeTheBackroomsGUiTest\Out;$(ExternalIncludePath)</ExternalIncludePath>
   </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='d|x64'">
+    <LibraryPath>$(VC_LibraryPath_x64);$(WindowsSDK_LibraryPath_x64);U:\DCInParis\EscapeTheBackroomsGUiTest\EscapeTheBackroomsGUiTest\vcpkg_Out\lib</LibraryPath>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+    <LibraryPath>$(VC_LibraryPath_x64);$(WindowsSDK_LibraryPath_x64);U:\DCInParis\EscapeTheBackroomsGUiTest\EscapeTheBackroomsGUiTest\vcpkg_Out\lib</LibraryPath>
+  </PropertyGroup>
   <PropertyGroup Label="Vcpkg" Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
     <VcpkgUseStatic>true</VcpkgUseStatic>
   </PropertyGroup>
   <PropertyGroup Label="Vcpkg" Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
     <VcpkgUseStatic>true</VcpkgUseStatic>
   </PropertyGroup>
+  <PropertyGroup Label="Vcpkg">
+    <VcpkgEnabled>false</VcpkgEnabled>
+  </PropertyGroup>
   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
     <ClCompile>
       <WarningLevel>Level3</WarningLevel>
@@ -150,6 +159,7 @@
       <SubSystem>Windows</SubSystem>
       <GenerateDebugInformation>true</GenerateDebugInformation>
       <EnableUAC>false</EnableUAC>
+      <AdditionalOptions>minhook.x64.lib %(AdditionalOptions)</AdditionalOptions>
     </Link>
   </ItemDefinitionGroup>
   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
@@ -171,6 +181,7 @@
       <OptimizeReferences>true</OptimizeReferences>
       <GenerateDebugInformation>true</GenerateDebugInformation>
       <EnableUAC>false</EnableUAC>
+      <AdditionalOptions>minhook.x64.lib %(AdditionalOptions)</AdditionalOptions>
     </Link>
   </ItemDefinitionGroup>
   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='d|Win32'">
@@ -182,6 +193,9 @@
     <ClCompile>
       <LanguageStandard>stdcpp20</LanguageStandard>
     </ClCompile>
+    <Link>
+      <AdditionalOptions>minhook.x64.lib %(AdditionalOptions)</AdditionalOptions>
+    </Link>
   </ItemDefinitionGroup>
   <ItemGroup>
     <ClInclude Include="Cheat.h" />

EscapeTheBackroomsGUiTest/GUI/ZeroGUI.h

@@ -320,6 +320,14 @@ namespace CWINGui
 			canvas->K2_DrawLine(FVector2D{ initial_pos.X, initial_pos.Y + i }, FVector2D{ initial_pos.X + w, initial_pos.Y + i }, 1.0f, color);
 	}
 
+	enum Rounding : short {
+		LeftCorner = 0x1,
+		RightCorner = 0x10,
+		LeftCornerDown = 0x100,
+		RightCornerDown = 0x1000,
+		AllCorners = 0x1111,
+	};
+
 	void DrawFilledCircle(FVector2D pos, float r, FLinearColor color)
 	{
 		float smooth = 0.07f;
@@ -712,6 +720,62 @@ namespace CWINGui
 		}
 	}
 	
+
+	void DrawRoundedFilledRect(UCanvas* canvas, FVector2D pos, FVector2D size, FLinearColor color, int Sidenumbers = 20, float rounding = 2.0f, Rounding flag = Rounding::AllCorners)
+	{
+		const float PI = 3.1415927f;
+
+		bool RoundLeftCornerUp = flag & Rounding::LeftCorner;
+		bool RoundRightCornerUp = flag & Rounding::RightCorner;
+		bool RoundLeftCornerDown = flag & Rounding::LeftCornerDown;
+		bool RoundRightCornerDown = flag & Rounding::RightCornerDown;
+
+		for (float y = 0.0f; y < size.Y; y += 1.0f)
+		{
+			FVector2D StartPos = { pos.X, pos.Y + y };
+			FVector2D EndPos = { pos.X + size.X, pos.Y + y };
+
+
+			if (RoundLeftCornerUp || RoundRightCornerUp && y < rounding)
+			{
+				if (RoundLeftCornerUp) {
+					float angle = (y / rounding) * (PI / 2);
+
+					StartPos.X += rounding * (1 - std::cosf(angle));
+					StartPos.Y += rounding * (1 - std::sinf(angle));
+				}
+				if (RoundRightCornerUp) {
+					float angle = (y / rounding) * (PI / 2);
+
+					EndPos.X -= rounding * (1 - std::cosf(angle));
+					EndPos.Y += rounding * (1 - std::sinf(angle));
+				}
+			}
+
+			if (RoundLeftCornerDown || RoundRightCornerDown && y > size.Y - rounding)
+			{
+				if (RoundLeftCornerDown) {
+					float dy = y - (size.Y - rounding);
+					float angle = (dy / rounding) * (PI / 2);
+
+					StartPos.X += rounding * (1 - std::cosf(angle));
+					StartPos.Y -= rounding * (1 - std::sinf(angle));
+				}
+				if (RoundRightCornerDown) {
+					float dy = y - (size.Y - rounding);
+					float angle = (dy / rounding) * (PI / 2);
+
+					EndPos.X -= rounding * (1 - std::cosf(angle));
+					EndPos.Y -= rounding * (1 - std::sinf(angle));
+				}
+			}
+
+			canvas->K2_DrawLine(StartPos, EndPos, 1.0f, color);
+
+		}
+	}
+
+
 	void Text(const wchar_t* text, bool center = false, bool outline = false)
 	{
 		elements_count++;

EscapeTheBackroomsGUiTest/Settings.h

@@ -192,6 +192,21 @@ namespace PlayerStuff {
 			}
 		}
 
+		static std::string SanitizeString(std::string Input) {
+			std::string output = "";
+
+			int Sizecc = Input.size();
+
+			for (size_t i = 0; i < 14; i++)
+			{
+				if (i >= Sizecc) break;
+
+				output += Input[i];
+			}
+
+			return output;
+		}
+
 		static std::wstring SanitizeWString(std::wstring Input) {
 			std::wstring output = L"";
 
@@ -328,6 +343,11 @@ namespace Settings {
 	float Host_PlayersGravityScale = 0.5f;
 	Host_Pawns hostPawn = Host_Pawns::defaultEmptyPawn;
 
+	//Anti Cheat
+	bool AntiCheat = false;
+	bool AC_InvalidItemSpawner = false;
+	bool AC_NameChanger = false;
+
 
 	//Misc
 

EscapeTheBackroomsGUiTest/dllmain.cpp

@@ -1,9 +1,11 @@
-#include "SDK/SDK.hpp"
+#include <thread>
-#include <thread>
 #include <algorithm>
+
+#include "vcpkg_Out/include/MinHook.h"
+#include "SDK/SDK.hpp"
+#include "Out/IncludeFile.h"
+
 #include "Cheat.h"
-#include <MinHook.h>
-#include <IncludeFile.h>
 #include "Config.h"
 
 FILE* ConsoleFile = nullptr;
@@ -311,13 +313,19 @@ void ProcessEventHook(SDK::UObject* Obj, SDK::UFunction* Function, void* Parms)
 			}
 		}
 
-		if (!IsLocalPlayer) {
+		if(CallingPawn->PlayerState)
+		     Cheat::Message(std::format("Spawned Item {} by Player: {}", (!Cheat::IsClassOfClass(params_->ItemClass, SDK::ABP_Item_C::StaticClass()) ? "Invalid Item" : params_->ItemClass->GetName()), PlayerStuff::Player::SanitizeString(CallingPawn->PlayerState->GetPlayerName().ToString())));
+		else
+			return;
 		
+
+		if (!IsLocalPlayer) {
 			if (auto ItemClass = params_->ItemClass; ItemClass) {
 
-				if (!ItemClass->IsA(SDK::ABP_Item_C::StaticClass())) {
+				if (!Cheat::IsClassOfClass(params_->ItemClass, SDK::ABP_Item_C::StaticClass())) {
 					if (IsLocalHost) {
 						Cheat::MessageW(L"Non Item was passed to SpawnEquipItem, kicking that bad Cheater!");
+
 						GameMode->KickPlayer(CallingPawn->PlayerState, CallingPawn->GetOwner(), (SDK::AMP_PlayerController_C*)CallingPawn->Controller, true, true);
 					}
 
@@ -332,6 +340,8 @@ void ProcessEventHook(SDK::UObject* Obj, SDK::UFunction* Function, void* Parms)
 				}
 			}
 		}
+
+		
 	}
 
 	
@@ -359,6 +369,7 @@ void ProcessEventHook(SDK::UObject* Obj, SDK::UFunction* Function, void* Parms)
 					}
 					else
 					{
+
 						PlayerNameChanges[i].second.push_back(NewName);
 						break;
 					}
@@ -481,15 +492,8 @@ void MainRender(SDK::UObject* object, SDK::UCanvas* Canvas) {
 				if (CWINGui::Window("?", &WindowPos, WindowSize, Settings::NewVersion_)) {
 					CWINGui::Text(std::format(L"New Version {}!!!", Settings::CheatVersion).c_str());
 
-					CWINGui::Text(L"* Added Server Sided Teleporting!");
+					CWINGui::Text(L"* Fixed Memory Leak Bug!");
-					CWINGui::Text(L"* Added Server Sided Object Spawner!");
+					CWINGui::Text(L"* Fixed Anti Cheat (Is off now by Default)!");
-					CWINGui::Text(L"* Added Boat to Object Spawner.");
-					CWINGui::Text(L"* Added Config System");
-					CWINGui::Text(L"* Added Rope on Player to Player Options.");
-					CWINGui::Text(L"* Added Freecam and Server Sided Teleporter in Freecam.");
-					CWINGui::Text(L"* Added Freecam and Server Sided Teleporter in Freecam.");
-					CWINGui::Text(L"* Added some new Menu Designing.");
-					CWINGui::Text(L"* Added Chat Spoofer.");
 
 					CWINGui::Text(L""), CWINGui::SameLine();
 

EscapeTheBackroomsGUiTest/vcpkg_Out/include/DirectXTex.h

@@ -0,0 +1,937 @@
+//-------------------------------------------------------------------------------------
+// DirectXTex.h
+//
+// DirectX Texture Library
+//
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+//
+// http://go.microsoft.com/fwlink/?LinkId=248926
+//-------------------------------------------------------------------------------------
+
+#pragma once
+
+#include <cstddef>
+#include <cstdint>
+#include <functional>
+#include <utility>
+#include <vector>
+
+#ifdef _WIN32
+#if !defined(__d3d11_h__) && !defined(__d3d11_x_h__) && !defined(__d3d12_h__) && !defined(__d3d12_x_h__) && !defined(__XBOX_D3D12_X__)
+#ifdef _GAMING_XBOX_SCARLETT
+#include <d3d12_xs.h>
+#elif defined(_GAMING_XBOX)
+#include <d3d12_x.h>
+#elif defined(_XBOX_ONE) && defined(_TITLE)
+#include <d3d11_x.h>
+#else
+#include <d3d11_1.h>
+#endif
+#endif
+#else // !WIN32
+#include <directx/dxgiformat.h>
+#include <wsl/winadapter.h>
+#endif
+
+#include <DirectXMath.h>
+
+#ifdef _WIN32
+#if defined(NTDDI_WIN10_FE) || defined(__MINGW32__)
+#include <ocidl.h>
+#else
+#include <OCIdl.h>
+#endif
+
+struct IWICImagingFactory;
+struct IWICMetadataQueryReader;
+#endif
+
+#define DIRECTX_TEX_VERSION 196
+
+
+namespace DirectX
+{
+
+    //---------------------------------------------------------------------------------
+    // DXGI Format Utilities
+    constexpr bool __cdecl IsValid(_In_ DXGI_FORMAT fmt) noexcept;
+    bool __cdecl IsCompressed(_In_ DXGI_FORMAT fmt) noexcept;
+    bool __cdecl IsPacked(_In_ DXGI_FORMAT fmt) noexcept;
+    bool __cdecl IsVideo(_In_ DXGI_FORMAT fmt) noexcept;
+    bool __cdecl IsPlanar(_In_ DXGI_FORMAT fmt) noexcept;
+    bool __cdecl IsPalettized(_In_ DXGI_FORMAT fmt) noexcept;
+    bool __cdecl IsDepthStencil(_In_ DXGI_FORMAT fmt) noexcept;
+    bool __cdecl IsSRGB(_In_ DXGI_FORMAT fmt) noexcept;
+    bool __cdecl IsBGR(_In_ DXGI_FORMAT fmt) noexcept;
+    bool __cdecl IsTypeless(_In_ DXGI_FORMAT fmt, _In_ bool partialTypeless = true) noexcept;
+
+    bool __cdecl HasAlpha(_In_ DXGI_FORMAT fmt) noexcept;
+
+    size_t __cdecl BitsPerPixel(_In_ DXGI_FORMAT fmt) noexcept;
+
+    size_t __cdecl BitsPerColor(_In_ DXGI_FORMAT fmt) noexcept;
+
+    enum FORMAT_TYPE
+    {
+        FORMAT_TYPE_TYPELESS,
+        FORMAT_TYPE_FLOAT,
+        FORMAT_TYPE_UNORM,
+        FORMAT_TYPE_SNORM,
+        FORMAT_TYPE_UINT,
+        FORMAT_TYPE_SINT,
+    };
+
+    FORMAT_TYPE __cdecl FormatDataType(_In_ DXGI_FORMAT fmt) noexcept;
+
+    enum CP_FLAGS : unsigned long
+    {
+        CP_FLAGS_NONE = 0x0,
+        // Normal operation
+
+        CP_FLAGS_LEGACY_DWORD = 0x1,
+        // Assume pitch is DWORD aligned instead of BYTE aligned
+
+        CP_FLAGS_PARAGRAPH = 0x2,
+        // Assume pitch is 16-byte aligned instead of BYTE aligned
+
+        CP_FLAGS_YMM = 0x4,
+        // Assume pitch is 32-byte aligned instead of BYTE aligned
+
+        CP_FLAGS_ZMM = 0x8,
+        // Assume pitch is 64-byte aligned instead of BYTE aligned
+
+        CP_FLAGS_PAGE4K = 0x200,
+        // Assume pitch is 4096-byte aligned instead of BYTE aligned
+
+        CP_FLAGS_BAD_DXTN_TAILS = 0x1000,
+        // BC formats with malformed mipchain blocks smaller than 4x4
+
+        CP_FLAGS_24BPP = 0x10000,
+        // Override with a legacy 24 bits-per-pixel format size
+
+        CP_FLAGS_16BPP = 0x20000,
+        // Override with a legacy 16 bits-per-pixel format size
+
+        CP_FLAGS_8BPP = 0x40000,
+        // Override with a legacy 8 bits-per-pixel format size
+    };
+
+    HRESULT __cdecl ComputePitch(
+        _In_ DXGI_FORMAT fmt, _In_ size_t width, _In_ size_t height,
+        _Out_ size_t& rowPitch, _Out_ size_t& slicePitch, _In_ CP_FLAGS flags = CP_FLAGS_NONE) noexcept;
+
+    size_t __cdecl ComputeScanlines(_In_ DXGI_FORMAT fmt, _In_ size_t height) noexcept;
+
+    DXGI_FORMAT __cdecl MakeSRGB(_In_ DXGI_FORMAT fmt) noexcept;
+    DXGI_FORMAT __cdecl MakeLinear(_In_ DXGI_FORMAT fmt) noexcept;
+    DXGI_FORMAT __cdecl MakeTypeless(_In_ DXGI_FORMAT fmt) noexcept;
+    DXGI_FORMAT __cdecl MakeTypelessUNORM(_In_ DXGI_FORMAT fmt) noexcept;
+    DXGI_FORMAT __cdecl MakeTypelessFLOAT(_In_ DXGI_FORMAT fmt) noexcept;
+
+    //---------------------------------------------------------------------------------
+    // Texture metadata
+    enum TEX_DIMENSION
+        // Subset here matches D3D10_RESOURCE_DIMENSION and D3D11_RESOURCE_DIMENSION
+    {
+        TEX_DIMENSION_TEXTURE1D = 2,
+        TEX_DIMENSION_TEXTURE2D = 3,
+        TEX_DIMENSION_TEXTURE3D = 4,
+    };
+
+    enum TEX_MISC_FLAG : unsigned long
+        // Subset here matches D3D10_RESOURCE_MISC_FLAG and D3D11_RESOURCE_MISC_FLAG
+    {
+        TEX_MISC_TEXTURECUBE = 0x4L,
+    };
+
+    enum TEX_MISC_FLAG2 : unsigned long
+    {
+        TEX_MISC2_ALPHA_MODE_MASK = 0x7L,
+    };
+
+    enum TEX_ALPHA_MODE
+        // Matches DDS_ALPHA_MODE, encoded in MISC_FLAGS2
+    {
+        TEX_ALPHA_MODE_UNKNOWN = 0,
+        TEX_ALPHA_MODE_STRAIGHT = 1,
+        TEX_ALPHA_MODE_PREMULTIPLIED = 2,
+        TEX_ALPHA_MODE_OPAQUE = 3,
+        TEX_ALPHA_MODE_CUSTOM = 4,
+    };
+
+    struct TexMetadata
+    {
+        size_t          width;
+        size_t          height;     // Should be 1 for 1D textures
+        size_t          depth;      // Should be 1 for 1D or 2D textures
+        size_t          arraySize;  // For cubemap, this is a multiple of 6
+        size_t          mipLevels;
+        uint32_t        miscFlags;
+        uint32_t        miscFlags2;
+        DXGI_FORMAT     format;
+        TEX_DIMENSION   dimension;
+
+        size_t __cdecl ComputeIndex(_In_ size_t mip, _In_ size_t item, _In_ size_t slice) const noexcept;
+            // Returns size_t(-1) to indicate an out-of-range error
+
+        bool __cdecl IsCubemap() const noexcept { return (miscFlags & TEX_MISC_TEXTURECUBE) != 0; }
+            // Helper for miscFlags
+
+        bool __cdecl IsPMAlpha() const noexcept { return ((miscFlags2 & TEX_MISC2_ALPHA_MODE_MASK) == TEX_ALPHA_MODE_PREMULTIPLIED) != 0; }
+        void __cdecl SetAlphaMode(TEX_ALPHA_MODE mode) noexcept { miscFlags2 = (miscFlags2 & ~static_cast<uint32_t>(TEX_MISC2_ALPHA_MODE_MASK)) | static_cast<uint32_t>(mode); }
+        TEX_ALPHA_MODE __cdecl GetAlphaMode() const noexcept { return static_cast<TEX_ALPHA_MODE>(miscFlags2 & TEX_MISC2_ALPHA_MODE_MASK); }
+            // Helpers for miscFlags2
+
+        bool __cdecl IsVolumemap() const noexcept { return (dimension == TEX_DIMENSION_TEXTURE3D); }
+            // Helper for dimension
+    };
+
+    enum DDS_FLAGS : unsigned long
+    {
+        DDS_FLAGS_NONE = 0x0,
+
+        DDS_FLAGS_LEGACY_DWORD = 0x1,
+        // Assume pitch is DWORD aligned instead of BYTE aligned (used by some legacy DDS files)
+
+        DDS_FLAGS_NO_LEGACY_EXPANSION = 0x2,
+        // Do not implicitly convert legacy formats that result in larger pixel sizes (24 bpp, 3:3:2, A8L8, A4L4, P8, A8P8)
+
+        DDS_FLAGS_NO_R10B10G10A2_FIXUP = 0x4,
+        // Do not use work-around for long-standing D3DX DDS file format issue which reversed the 10:10:10:2 color order masks
+
+        DDS_FLAGS_FORCE_RGB = 0x8,
+        // Convert DXGI 1.1 BGR formats to DXGI_FORMAT_R8G8B8A8_UNORM to avoid use of optional WDDM 1.1 formats
+
+        DDS_FLAGS_NO_16BPP = 0x10,
+        // Conversions avoid use of 565, 5551, and 4444 formats and instead expand to 8888 to avoid use of optional WDDM 1.2 formats
+
+        DDS_FLAGS_EXPAND_LUMINANCE = 0x20,
+        // When loading legacy luminance formats expand replicating the color channels rather than leaving them packed (L8, L16, A8L8)
+
+        DDS_FLAGS_BAD_DXTN_TAILS = 0x40,
+        // Some older DXTn DDS files incorrectly handle mipchain tails for blocks smaller than 4x4
+
+        DDS_FLAGS_FORCE_DX10_EXT = 0x10000,
+        // Always use the 'DX10' header extension for DDS writer (i.e. don't try to write DX9 compatible DDS files)
+
+        DDS_FLAGS_FORCE_DX10_EXT_MISC2 = 0x20000,
+        // DDS_FLAGS_FORCE_DX10_EXT including miscFlags2 information (result may not be compatible with D3DX10 or D3DX11)
+
+        DDS_FLAGS_FORCE_DX9_LEGACY = 0x40000,
+        // Force use of legacy header for DDS writer (will fail if unable to write as such)
+
+        DDS_FLAGS_ALLOW_LARGE_FILES = 0x1000000,
+        // Enables the loader to read large dimension .dds files (i.e. greater than known hardware requirements)
+    };
+
+    enum TGA_FLAGS : unsigned long
+    {
+        TGA_FLAGS_NONE = 0x0,
+
+        TGA_FLAGS_BGR = 0x1,
+        // 24bpp files are returned as BGRX; 32bpp files are returned as BGRA
+
+        TGA_FLAGS_ALLOW_ALL_ZERO_ALPHA = 0x2,
+        // If the loaded image has an all zero alpha channel, normally we assume it should be opaque. This flag leaves it alone.
+
+        TGA_FLAGS_IGNORE_SRGB = 0x10,
+        // Ignores sRGB TGA 2.0 metadata if present in the file
+
+        TGA_FLAGS_FORCE_SRGB = 0x20,
+        // Writes sRGB metadata into the file reguardless of format (TGA 2.0 only)
+
+        TGA_FLAGS_FORCE_LINEAR = 0x40,
+        // Writes linear gamma metadata into the file reguardless of format (TGA 2.0 only)
+
+        TGA_FLAGS_DEFAULT_SRGB = 0x80,
+        // If no colorspace is specified in TGA 2.0 metadata, assume sRGB
+    };
+
+    enum WIC_FLAGS : unsigned long
+    {
+        WIC_FLAGS_NONE = 0x0,
+
+        WIC_FLAGS_FORCE_RGB = 0x1,
+        // Loads DXGI 1.1 BGR formats as DXGI_FORMAT_R8G8B8A8_UNORM to avoid use of optional WDDM 1.1 formats
+
+        WIC_FLAGS_NO_X2_BIAS = 0x2,
+        // Loads DXGI 1.1 X2 10:10:10:2 format as DXGI_FORMAT_R10G10B10A2_UNORM
+
+        WIC_FLAGS_NO_16BPP = 0x4,
+        // Loads 565, 5551, and 4444 formats as 8888 to avoid use of optional WDDM 1.2 formats
+
+        WIC_FLAGS_ALLOW_MONO = 0x8,
+        // Loads 1-bit monochrome (black & white) as R1_UNORM rather than 8-bit grayscale
+
+        WIC_FLAGS_ALL_FRAMES = 0x10,
+        // Loads all images in a multi-frame file, converting/resizing to match the first frame as needed, defaults to 0th frame otherwise
+
+        WIC_FLAGS_IGNORE_SRGB = 0x20,
+        // Ignores sRGB metadata if present in the file
+
+        WIC_FLAGS_FORCE_SRGB = 0x40,
+        // Writes sRGB metadata into the file reguardless of format
+
+        WIC_FLAGS_FORCE_LINEAR = 0x80,
+        // Writes linear gamma metadata into the file reguardless of format
+
+        WIC_FLAGS_DEFAULT_SRGB = 0x100,
+        // If no colorspace is specified, assume sRGB
+
+        WIC_FLAGS_DITHER = 0x10000,
+        // Use ordered 4x4 dithering for any required conversions
+
+        WIC_FLAGS_DITHER_DIFFUSION = 0x20000,
+        // Use error-diffusion dithering for any required conversions
+
+        WIC_FLAGS_FILTER_POINT = 0x100000,
+        WIC_FLAGS_FILTER_LINEAR = 0x200000,
+        WIC_FLAGS_FILTER_CUBIC = 0x300000,
+        WIC_FLAGS_FILTER_FANT = 0x400000, // Combination of Linear and Box filter
+            // Filtering mode to use for any required image resizing (only needed when loading arrays of differently sized images; defaults to Fant)
+    };
+
+    HRESULT __cdecl GetMetadataFromDDSMemory(
+        _In_reads_bytes_(size) const void* pSource, _In_ size_t size,
+        _In_ DDS_FLAGS flags,
+        _Out_ TexMetadata& metadata) noexcept;
+    HRESULT __cdecl GetMetadataFromDDSFile(
+        _In_z_ const wchar_t* szFile,
+        _In_ DDS_FLAGS flags,
+        _Out_ TexMetadata& metadata) noexcept;
+
+    HRESULT __cdecl GetMetadataFromHDRMemory(
+        _In_reads_bytes_(size) const void* pSource, _In_ size_t size,
+        _Out_ TexMetadata& metadata) noexcept;
+    HRESULT __cdecl GetMetadataFromHDRFile(
+        _In_z_ const wchar_t* szFile,
+        _Out_ TexMetadata& metadata) noexcept;
+
+    HRESULT __cdecl GetMetadataFromTGAMemory(
+        _In_reads_bytes_(size) const void* pSource, _In_ size_t size,
+        _In_ TGA_FLAGS flags,
+        _Out_ TexMetadata& metadata) noexcept;
+    HRESULT __cdecl GetMetadataFromTGAFile(
+        _In_z_ const wchar_t* szFile,
+        _In_ TGA_FLAGS flags,
+        _Out_ TexMetadata& metadata) noexcept;
+
+#ifdef _WIN32
+    HRESULT __cdecl GetMetadataFromWICMemory(
+        _In_reads_bytes_(size) const void* pSource, _In_ size_t size,
+        _In_ WIC_FLAGS flags,
+        _Out_ TexMetadata& metadata,
+        _In_opt_ std::function<void __cdecl(IWICMetadataQueryReader*)> getMQR = nullptr);
+
+    HRESULT __cdecl GetMetadataFromWICFile(
+        _In_z_ const wchar_t* szFile,
+        _In_ WIC_FLAGS flags,
+        _Out_ TexMetadata& metadata,
+        _In_opt_ std::function<void __cdecl(IWICMetadataQueryReader*)> getMQR = nullptr);
+#endif
+
+    // Compatability helpers
+    HRESULT __cdecl GetMetadataFromTGAMemory(
+        _In_reads_bytes_(size) const void* pSource, _In_ size_t size,
+        _Out_ TexMetadata& metadata) noexcept;
+    HRESULT __cdecl GetMetadataFromTGAFile(
+        _In_z_ const wchar_t* szFile,
+        _Out_ TexMetadata& metadata) noexcept;
+
+    //---------------------------------------------------------------------------------
+    // Bitmap image container
+    struct Image
+    {
+        size_t      width;
+        size_t      height;
+        DXGI_FORMAT format;
+        size_t      rowPitch;
+        size_t      slicePitch;
+        uint8_t*    pixels;
+    };
+
+    class ScratchImage
+    {
+    public:
+        ScratchImage() noexcept
+            : m_nimages(0), m_size(0), m_metadata{}, m_image(nullptr), m_memory(nullptr) {}
+        ScratchImage(ScratchImage&& moveFrom) noexcept
+            : m_nimages(0), m_size(0), m_metadata{}, m_image(nullptr), m_memory(nullptr) { *this = std::move(moveFrom); }
+        ~ScratchImage() { Release(); }
+
+        ScratchImage& __cdecl operator= (ScratchImage&& moveFrom) noexcept;
+
+        ScratchImage(const ScratchImage&) = delete;
+        ScratchImage& operator=(const ScratchImage&) = delete;
+
+        HRESULT __cdecl Initialize(_In_ const TexMetadata& mdata, _In_ CP_FLAGS flags = CP_FLAGS_NONE) noexcept;
+
+        HRESULT __cdecl Initialize1D(_In_ DXGI_FORMAT fmt, _In_ size_t length, _In_ size_t arraySize, _In_ size_t mipLevels, _In_ CP_FLAGS flags = CP_FLAGS_NONE) noexcept;
+        HRESULT __cdecl Initialize2D(_In_ DXGI_FORMAT fmt, _In_ size_t width, _In_ size_t height, _In_ size_t arraySize, _In_ size_t mipLevels, _In_ CP_FLAGS flags = CP_FLAGS_NONE) noexcept;
+        HRESULT __cdecl Initialize3D(_In_ DXGI_FORMAT fmt, _In_ size_t width, _In_ size_t height, _In_ size_t depth, _In_ size_t mipLevels, _In_ CP_FLAGS flags = CP_FLAGS_NONE) noexcept;
+        HRESULT __cdecl InitializeCube(_In_ DXGI_FORMAT fmt, _In_ size_t width, _In_ size_t height, _In_ size_t nCubes, _In_ size_t mipLevels, _In_ CP_FLAGS flags = CP_FLAGS_NONE) noexcept;
+
+        HRESULT __cdecl InitializeFromImage(_In_ const Image& srcImage, _In_ bool allow1D = false, _In_ CP_FLAGS flags = CP_FLAGS_NONE) noexcept;
+        HRESULT __cdecl InitializeArrayFromImages(_In_reads_(nImages) const Image* images, _In_ size_t nImages, _In_ bool allow1D = false, _In_ CP_FLAGS flags = CP_FLAGS_NONE) noexcept;
+        HRESULT __cdecl InitializeCubeFromImages(_In_reads_(nImages) const Image* images, _In_ size_t nImages, _In_ CP_FLAGS flags = CP_FLAGS_NONE) noexcept;
+        HRESULT __cdecl Initialize3DFromImages(_In_reads_(depth) const Image* images, _In_ size_t depth, _In_ CP_FLAGS flags = CP_FLAGS_NONE) noexcept;
+
+        void __cdecl Release() noexcept;
+
+        bool __cdecl OverrideFormat(_In_ DXGI_FORMAT f) noexcept;
+
+        const TexMetadata& __cdecl GetMetadata() const noexcept { return m_metadata; }
+        const Image* __cdecl GetImage(_In_ size_t mip, _In_ size_t item, _In_ size_t slice) const noexcept;
+
+        const Image* __cdecl GetImages() const noexcept { return m_image; }
+        size_t __cdecl GetImageCount() const noexcept { return m_nimages; }
+
+        uint8_t* __cdecl GetPixels() const noexcept { return m_memory; }
+        size_t __cdecl GetPixelsSize() const noexcept { return m_size; }
+
+        bool __cdecl IsAlphaAllOpaque() const noexcept;
+
+    private:
+        size_t      m_nimages;
+        size_t      m_size;
+        TexMetadata m_metadata;
+        Image*      m_image;
+        uint8_t*    m_memory;
+    };
+
+    //---------------------------------------------------------------------------------
+    // Memory blob (allocated buffer pointer is always 16-byte aligned)
+    class Blob
+    {
+    public:
+        Blob() noexcept : m_buffer(nullptr), m_size(0) {}
+        Blob(Blob&& moveFrom) noexcept : m_buffer(nullptr), m_size(0) { *this = std::move(moveFrom); }
+        ~Blob() { Release(); }
+
+        Blob& __cdecl operator= (Blob&& moveFrom) noexcept;
+
+        Blob(const Blob&) = delete;
+        Blob& operator=(const Blob&) = delete;
+
+        HRESULT __cdecl Initialize(_In_ size_t size) noexcept;
+
+        void __cdecl Release() noexcept;
+
+        void *__cdecl GetBufferPointer() const noexcept { return m_buffer; }
+        size_t __cdecl GetBufferSize() const noexcept { return m_size; }
+
+        HRESULT __cdecl Resize(size_t size) noexcept;
+            // Reallocate for a new size
+
+        HRESULT __cdecl Trim(size_t size) noexcept;
+            // Shorten size without reallocation
+
+    private:
+        void*   m_buffer;
+        size_t  m_size;
+    };
+
+    //---------------------------------------------------------------------------------
+    // Image I/O
+
+    // DDS operations
+    HRESULT __cdecl LoadFromDDSMemory(
+        _In_reads_bytes_(size) const void* pSource, _In_ size_t size,
+        _In_ DDS_FLAGS flags,
+        _Out_opt_ TexMetadata* metadata, _Out_ ScratchImage& image) noexcept;
+    HRESULT __cdecl LoadFromDDSFile(
+        _In_z_ const wchar_t* szFile,
+        _In_ DDS_FLAGS flags,
+        _Out_opt_ TexMetadata* metadata, _Out_ ScratchImage& image) noexcept;
+
+    HRESULT __cdecl SaveToDDSMemory(
+        _In_ const Image& image,
+        _In_ DDS_FLAGS flags,
+        _Out_ Blob& blob) noexcept;
+    HRESULT __cdecl SaveToDDSMemory(
+        _In_reads_(nimages) const Image* images, _In_ size_t nimages, _In_ const TexMetadata& metadata,
+        _In_ DDS_FLAGS flags,
+        _Out_ Blob& blob) noexcept;
+
+    HRESULT __cdecl SaveToDDSFile(_In_ const Image& image, _In_ DDS_FLAGS flags, _In_z_ const wchar_t* szFile) noexcept;
+    HRESULT __cdecl SaveToDDSFile(
+        _In_reads_(nimages) const Image* images, _In_ size_t nimages, _In_ const TexMetadata& metadata,
+        _In_ DDS_FLAGS flags, _In_z_ const wchar_t* szFile) noexcept;
+
+    // HDR operations
+    HRESULT __cdecl LoadFromHDRMemory(
+        _In_reads_bytes_(size) const void* pSource, _In_ size_t size,
+        _Out_opt_ TexMetadata* metadata, _Out_ ScratchImage& image) noexcept;
+    HRESULT __cdecl LoadFromHDRFile(
+        _In_z_ const wchar_t* szFile,
+        _Out_opt_ TexMetadata* metadata, _Out_ ScratchImage& image) noexcept;
+
+    HRESULT __cdecl SaveToHDRMemory(_In_ const Image& image, _Out_ Blob& blob) noexcept;
+    HRESULT __cdecl SaveToHDRFile(_In_ const Image& image, _In_z_ const wchar_t* szFile) noexcept;
+
+    // TGA operations
+    HRESULT __cdecl LoadFromTGAMemory(
+        _In_reads_bytes_(size) const void* pSource, _In_ size_t size,
+        _In_ TGA_FLAGS flags,
+        _Out_opt_ TexMetadata* metadata, _Out_ ScratchImage& image) noexcept;
+    HRESULT __cdecl LoadFromTGAFile(
+        _In_z_ const wchar_t* szFile,
+        _In_ TGA_FLAGS flags,
+        _Out_opt_ TexMetadata* metadata, _Out_ ScratchImage& image) noexcept;
+
+    HRESULT __cdecl SaveToTGAMemory(_In_ const Image& image,
+        _In_ TGA_FLAGS flags,
+        _Out_ Blob& blob, _In_opt_ const TexMetadata* metadata = nullptr) noexcept;
+    HRESULT __cdecl SaveToTGAFile(_In_ const Image& image,
+        _In_ TGA_FLAGS flags,
+        _In_z_ const wchar_t* szFile, _In_opt_ const TexMetadata* metadata = nullptr) noexcept;
+
+    // WIC operations
+#ifdef _WIN32
+    HRESULT __cdecl LoadFromWICMemory(
+        _In_reads_bytes_(size) const void* pSource, _In_ size_t size,
+        _In_ WIC_FLAGS flags,
+        _Out_opt_ TexMetadata* metadata, _Out_ ScratchImage& image,
+        _In_opt_ std::function<void __cdecl(IWICMetadataQueryReader*)> getMQR = nullptr);
+    HRESULT __cdecl LoadFromWICFile(
+        _In_z_ const wchar_t* szFile, _In_ WIC_FLAGS flags,
+        _Out_opt_ TexMetadata* metadata, _Out_ ScratchImage& image,
+        _In_opt_ std::function<void __cdecl(IWICMetadataQueryReader*)> getMQR = nullptr);
+
+    HRESULT __cdecl SaveToWICMemory(
+        _In_ const Image& image, _In_ WIC_FLAGS flags, _In_ REFGUID guidContainerFormat,
+        _Out_ Blob& blob, _In_opt_ const GUID* targetFormat = nullptr,
+        _In_opt_ std::function<void __cdecl(IPropertyBag2*)> setCustomProps = nullptr);
+    HRESULT __cdecl SaveToWICMemory(
+        _In_count_(nimages) const Image* images, _In_ size_t nimages,
+        _In_ WIC_FLAGS flags, _In_ REFGUID guidContainerFormat,
+        _Out_ Blob& blob, _In_opt_ const GUID* targetFormat = nullptr,
+        _In_opt_ std::function<void __cdecl(IPropertyBag2*)> setCustomProps = nullptr);
+
+    HRESULT __cdecl SaveToWICFile(
+        _In_ const Image& image, _In_ WIC_FLAGS flags, _In_ REFGUID guidContainerFormat,
+        _In_z_ const wchar_t* szFile, _In_opt_ const GUID* targetFormat = nullptr,
+        _In_opt_ std::function<void __cdecl(IPropertyBag2*)> setCustomProps = nullptr);
+    HRESULT __cdecl SaveToWICFile(
+        _In_count_(nimages) const Image* images, _In_ size_t nimages,
+        _In_ WIC_FLAGS flags, _In_ REFGUID guidContainerFormat,
+        _In_z_ const wchar_t* szFile, _In_opt_ const GUID* targetFormat = nullptr,
+        _In_opt_ std::function<void __cdecl(IPropertyBag2*)> setCustomProps = nullptr);
+#endif // WIN32
+
+    // Compatability helpers
+    HRESULT __cdecl LoadFromTGAMemory(
+        _In_reads_bytes_(size) const void* pSource, _In_ size_t size,
+        _Out_opt_ TexMetadata* metadata, _Out_ ScratchImage& image) noexcept;
+    HRESULT __cdecl LoadFromTGAFile(
+        _In_z_ const wchar_t* szFile,
+        _Out_opt_ TexMetadata* metadata, _Out_ ScratchImage& image) noexcept;
+
+    HRESULT __cdecl SaveToTGAMemory(_In_ const Image& image, _Out_ Blob& blob, _In_opt_ const TexMetadata* metadata = nullptr) noexcept;
+    HRESULT __cdecl SaveToTGAFile(_In_ const Image& image, _In_z_ const wchar_t* szFile, _In_opt_ const TexMetadata* metadata = nullptr) noexcept;
+
+    //---------------------------------------------------------------------------------
+    // Texture conversion, resizing, mipmap generation, and block compression
+
+    enum TEX_FR_FLAGS : unsigned long
+    {
+        TEX_FR_ROTATE0 = 0x0,
+        TEX_FR_ROTATE90 = 0x1,
+        TEX_FR_ROTATE180 = 0x2,
+        TEX_FR_ROTATE270 = 0x3,
+        TEX_FR_FLIP_HORIZONTAL = 0x08,
+        TEX_FR_FLIP_VERTICAL = 0x10,
+    };
+
+#ifdef _WIN32
+    HRESULT __cdecl FlipRotate(_In_ const Image& srcImage, _In_ TEX_FR_FLAGS flags, _Out_ ScratchImage& image) noexcept;
+    HRESULT __cdecl FlipRotate(
+        _In_reads_(nimages) const Image* srcImages, _In_ size_t nimages, _In_ const TexMetadata& metadata,
+        _In_ TEX_FR_FLAGS flags, _Out_ ScratchImage& result) noexcept;
+        // Flip and/or rotate image
+#endif
+
+    enum TEX_FILTER_FLAGS : unsigned long
+    {
+        TEX_FILTER_DEFAULT = 0,
+
+        TEX_FILTER_WRAP_U = 0x1,
+        TEX_FILTER_WRAP_V = 0x2,
+        TEX_FILTER_WRAP_W = 0x4,
+        TEX_FILTER_WRAP = (TEX_FILTER_WRAP_U | TEX_FILTER_WRAP_V | TEX_FILTER_WRAP_W),
+        TEX_FILTER_MIRROR_U = 0x10,
+        TEX_FILTER_MIRROR_V = 0x20,
+        TEX_FILTER_MIRROR_W = 0x40,
+        TEX_FILTER_MIRROR = (TEX_FILTER_MIRROR_U | TEX_FILTER_MIRROR_V | TEX_FILTER_MIRROR_W),
+        // Wrap vs. Mirror vs. Clamp filtering options
+
+        TEX_FILTER_SEPARATE_ALPHA = 0x100,
+        // Resize color and alpha channel independently
+
+        TEX_FILTER_FLOAT_X2BIAS = 0x200,
+        // Enable *2 - 1 conversion cases for unorm<->float and positive-only float formats
+
+        TEX_FILTER_RGB_COPY_RED = 0x1000,
+        TEX_FILTER_RGB_COPY_GREEN = 0x2000,
+        TEX_FILTER_RGB_COPY_BLUE = 0x4000,
+        // When converting RGB to R, defaults to using grayscale. These flags indicate copying a specific channel instead
+        // When converting RGB to RG, defaults to copying RED | GREEN. These flags control which channels are selected instead.
+
+        TEX_FILTER_DITHER = 0x10000,
+        // Use ordered 4x4 dithering for any required conversions
+        TEX_FILTER_DITHER_DIFFUSION = 0x20000,
+        // Use error-diffusion dithering for any required conversions
+
+        TEX_FILTER_POINT = 0x100000,
+        TEX_FILTER_LINEAR = 0x200000,
+        TEX_FILTER_CUBIC = 0x300000,
+        TEX_FILTER_BOX = 0x400000,
+        TEX_FILTER_FANT = 0x400000, // Equiv to Box filtering for mipmap generation
+        TEX_FILTER_TRIANGLE = 0x500000,
+        // Filtering mode to use for any required image resizing
+
+        TEX_FILTER_SRGB_IN = 0x1000000,
+        TEX_FILTER_SRGB_OUT = 0x2000000,
+        TEX_FILTER_SRGB = (TEX_FILTER_SRGB_IN | TEX_FILTER_SRGB_OUT),
+        // sRGB <-> RGB for use in conversion operations
+        // if the input format type is IsSRGB(), then SRGB_IN is on by default
+        // if the output format type is IsSRGB(), then SRGB_OUT is on by default
+
+        TEX_FILTER_FORCE_NON_WIC = 0x10000000,
+        // Forces use of the non-WIC path when both are an option
+
+        TEX_FILTER_FORCE_WIC = 0x20000000,
+        // Forces use of the WIC path even when logic would have picked a non-WIC path when both are an option
+    };
+
+    constexpr unsigned long TEX_FILTER_DITHER_MASK = 0xF0000;
+    constexpr unsigned long TEX_FILTER_MODE_MASK = 0xF00000;
+    constexpr unsigned long TEX_FILTER_SRGB_MASK = 0xF000000;
+
+    HRESULT __cdecl Resize(
+        _In_ const Image& srcImage, _In_ size_t width, _In_ size_t height,
+        _In_ TEX_FILTER_FLAGS filter,
+        _Out_ ScratchImage& image) noexcept;
+    HRESULT __cdecl Resize(
+        _In_reads_(nimages) const Image* srcImages, _In_ size_t nimages, _In_ const TexMetadata& metadata,
+        _In_ size_t width, _In_ size_t height, _In_ TEX_FILTER_FLAGS filter, _Out_ ScratchImage& result) noexcept;
+        // Resize the image to width x height. Defaults to Fant filtering.
+        // Note for a complex resize, the result will always have mipLevels == 1
+
+    constexpr float TEX_THRESHOLD_DEFAULT = 0.5f;
+        // Default value for alpha threshold used when converting to 1-bit alpha
+
+    HRESULT __cdecl Convert(
+        _In_ const Image& srcImage, _In_ DXGI_FORMAT format, _In_ TEX_FILTER_FLAGS filter, _In_ float threshold,
+        _Out_ ScratchImage& image) noexcept;
+    HRESULT __cdecl Convert(
+        _In_reads_(nimages) const Image* srcImages, _In_ size_t nimages, _In_ const TexMetadata& metadata,
+        _In_ DXGI_FORMAT format, _In_ TEX_FILTER_FLAGS filter, _In_ float threshold, _Out_ ScratchImage& result) noexcept;
+        // Convert the image to a new format
+
+    HRESULT __cdecl ConvertToSinglePlane(_In_ const Image& srcImage, _Out_ ScratchImage& image) noexcept;
+    HRESULT __cdecl ConvertToSinglePlane(
+        _In_reads_(nimages) const Image* srcImages, _In_ size_t nimages, _In_ const TexMetadata& metadata,
+        _Out_ ScratchImage& image) noexcept;
+        // Converts the image from a planar format to an equivalent non-planar format
+
+    HRESULT __cdecl GenerateMipMaps(
+        _In_ const Image& baseImage, _In_ TEX_FILTER_FLAGS filter, _In_ size_t levels,
+        _Inout_ ScratchImage& mipChain, _In_ bool allow1D = false) noexcept;
+    HRESULT __cdecl GenerateMipMaps(
+        _In_reads_(nimages) const Image* srcImages, _In_ size_t nimages, _In_ const TexMetadata& metadata,
+        _In_ TEX_FILTER_FLAGS filter, _In_ size_t levels, _Inout_ ScratchImage& mipChain);
+        // levels of '0' indicates a full mipchain, otherwise is generates that number of total levels (including the source base image)
+        // Defaults to Fant filtering which is equivalent to a box filter
+
+    HRESULT __cdecl GenerateMipMaps3D(
+        _In_reads_(depth) const Image* baseImages, _In_ size_t depth, _In_ TEX_FILTER_FLAGS filter, _In_ size_t levels,
+        _Out_ ScratchImage& mipChain) noexcept;
+    HRESULT __cdecl GenerateMipMaps3D(
+        _In_reads_(nimages) const Image* srcImages, _In_ size_t nimages, _In_ const TexMetadata& metadata,
+        _In_ TEX_FILTER_FLAGS filter, _In_ size_t levels, _Out_ ScratchImage& mipChain);
+        // levels of '0' indicates a full mipchain, otherwise is generates that number of total levels (including the source base image)
+        // Defaults to Fant filtering which is equivalent to a box filter
+
+    HRESULT __cdecl ScaleMipMapsAlphaForCoverage(
+        _In_reads_(nimages) const Image* srcImages, _In_ size_t nimages, _In_ const TexMetadata& metadata, _In_ size_t item,
+        _In_ float alphaReference, _Inout_ ScratchImage& mipChain) noexcept;
+
+
+    enum TEX_PMALPHA_FLAGS : unsigned long
+    {
+        TEX_PMALPHA_DEFAULT = 0,
+
+        TEX_PMALPHA_IGNORE_SRGB = 0x1,
+        // ignores sRGB colorspace conversions
+
+        TEX_PMALPHA_REVERSE = 0x2,
+        // converts from premultiplied alpha back to straight alpha
+
+        TEX_PMALPHA_SRGB_IN = 0x1000000,
+        TEX_PMALPHA_SRGB_OUT = 0x2000000,
+        TEX_PMALPHA_SRGB = (TEX_PMALPHA_SRGB_IN | TEX_PMALPHA_SRGB_OUT),
+        // if the input format type is IsSRGB(), then SRGB_IN is on by default
+        // if the output format type is IsSRGB(), then SRGB_OUT is on by default
+    };
+
+    HRESULT __cdecl PremultiplyAlpha(_In_ const Image& srcImage, _In_ TEX_PMALPHA_FLAGS flags, _Out_ ScratchImage& image) noexcept;
+    HRESULT __cdecl PremultiplyAlpha(
+        _In_reads_(nimages) const Image* srcImages, _In_ size_t nimages, _In_ const TexMetadata& metadata,
+        _In_ TEX_PMALPHA_FLAGS flags, _Out_ ScratchImage& result) noexcept;
+        // Converts to/from a premultiplied alpha version of the texture
+
+    enum TEX_COMPRESS_FLAGS : unsigned long
+    {
+        TEX_COMPRESS_DEFAULT = 0,
+
+        TEX_COMPRESS_RGB_DITHER = 0x10000,
+        // Enables dithering RGB colors for BC1-3 compression
+
+        TEX_COMPRESS_A_DITHER = 0x20000,
+        // Enables dithering alpha for BC1-3 compression
+
+        TEX_COMPRESS_DITHER = 0x30000,
+        // Enables both RGB and alpha dithering for BC1-3 compression
+
+        TEX_COMPRESS_UNIFORM = 0x40000,
+        // Uniform color weighting for BC1-3 compression; by default uses perceptual weighting
+
+        TEX_COMPRESS_BC7_USE_3SUBSETS = 0x80000,
+        // Enables exhaustive search for BC7 compress for mode 0 and 2; by default skips trying these modes
+
+        TEX_COMPRESS_BC7_QUICK = 0x100000,
+        // Minimal modes (usually mode 6) for BC7 compression
+
+        TEX_COMPRESS_SRGB_IN = 0x1000000,
+        TEX_COMPRESS_SRGB_OUT = 0x2000000,
+        TEX_COMPRESS_SRGB = (TEX_COMPRESS_SRGB_IN | TEX_COMPRESS_SRGB_OUT),
+        // if the input format type is IsSRGB(), then SRGB_IN is on by default
+        // if the output format type is IsSRGB(), then SRGB_OUT is on by default
+
+        TEX_COMPRESS_PARALLEL = 0x10000000,
+        // Compress is free to use multithreading to improve performance (by default it does not use multithreading)
+    };
+
+    HRESULT __cdecl Compress(
+        _In_ const Image& srcImage, _In_ DXGI_FORMAT format, _In_ TEX_COMPRESS_FLAGS compress, _In_ float threshold,
+        _Out_ ScratchImage& cImage) noexcept;
+    HRESULT __cdecl Compress(
+        _In_reads_(nimages) const Image* srcImages, _In_ size_t nimages, _In_ const TexMetadata& metadata,
+        _In_ DXGI_FORMAT format, _In_ TEX_COMPRESS_FLAGS compress, _In_ float threshold, _Out_ ScratchImage& cImages) noexcept;
+        // Note that threshold is only used by BC1. TEX_THRESHOLD_DEFAULT is a typical value to use
+
+#if defined(__d3d11_h__) || defined(__d3d11_x_h__)
+    HRESULT __cdecl Compress(
+        _In_ ID3D11Device* pDevice, _In_ const Image& srcImage, _In_ DXGI_FORMAT format, _In_ TEX_COMPRESS_FLAGS compress,
+        _In_ float alphaWeight, _Out_ ScratchImage& image) noexcept;
+    HRESULT __cdecl Compress(
+        _In_ ID3D11Device* pDevice, _In_ const Image* srcImages, _In_ size_t nimages, _In_ const TexMetadata& metadata,
+        _In_ DXGI_FORMAT format, _In_ TEX_COMPRESS_FLAGS compress, _In_ float alphaWeight, _Out_ ScratchImage& cImages) noexcept;
+        // DirectCompute-based compression (alphaWeight is only used by BC7. 1.0 is the typical value to use)
+#endif
+
+    HRESULT __cdecl Decompress(_In_ const Image& cImage, _In_ DXGI_FORMAT format, _Out_ ScratchImage& image) noexcept;
+    HRESULT __cdecl Decompress(
+        _In_reads_(nimages) const Image* cImages, _In_ size_t nimages, _In_ const TexMetadata& metadata,
+        _In_ DXGI_FORMAT format, _Out_ ScratchImage& images) noexcept;
+
+    //---------------------------------------------------------------------------------
+    // Normal map operations
+
+    enum CNMAP_FLAGS : unsigned long
+    {
+        CNMAP_DEFAULT = 0,
+
+        CNMAP_CHANNEL_RED = 0x1,
+        CNMAP_CHANNEL_GREEN = 0x2,
+        CNMAP_CHANNEL_BLUE = 0x3,
+        CNMAP_CHANNEL_ALPHA = 0x4,
+        CNMAP_CHANNEL_LUMINANCE = 0x5,
+        // Channel selection when evaluting color value for height
+        // Luminance is a combination of red, green, and blue
+
+        CNMAP_MIRROR_U = 0x1000,
+        CNMAP_MIRROR_V = 0x2000,
+        CNMAP_MIRROR = 0x3000,
+        // Use mirror semantics for scanline references (defaults to wrap)
+
+        CNMAP_INVERT_SIGN = 0x4000,
+        // Inverts normal sign
+
+        CNMAP_COMPUTE_OCCLUSION = 0x8000,
+        // Computes a crude occlusion term stored in the alpha channel
+    };
+
+    HRESULT __cdecl ComputeNormalMap(
+        _In_ const Image& srcImage, _In_ CNMAP_FLAGS flags, _In_ float amplitude,
+        _In_ DXGI_FORMAT format, _Out_ ScratchImage& normalMap) noexcept;
+    HRESULT __cdecl ComputeNormalMap(
+        _In_reads_(nimages) const Image* srcImages, _In_ size_t nimages, _In_ const TexMetadata& metadata,
+        _In_ CNMAP_FLAGS flags, _In_ float amplitude, _In_ DXGI_FORMAT format, _Out_ ScratchImage& normalMaps) noexcept;
+
+    //---------------------------------------------------------------------------------
+    // Misc image operations
+
+    struct Rect
+    {
+        size_t x;
+        size_t y;
+        size_t w;
+        size_t h;
+
+        Rect() = default;
+        Rect(size_t _x, size_t _y, size_t _w, size_t _h) noexcept : x(_x), y(_y), w(_w), h(_h) {}
+    };
+
+    HRESULT __cdecl CopyRectangle(
+        _In_ const Image& srcImage, _In_ const Rect& srcRect, _In_ const Image& dstImage,
+        _In_ TEX_FILTER_FLAGS filter, _In_ size_t xOffset, _In_ size_t yOffset) noexcept;
+
+    enum CMSE_FLAGS : unsigned long
+    {
+        CMSE_DEFAULT = 0,
+
+        CMSE_IMAGE1_SRGB = 0x1,
+        CMSE_IMAGE2_SRGB = 0x2,
+        // Indicates that image needs gamma correction before comparision
+
+        CMSE_IGNORE_RED = 0x10,
+        CMSE_IGNORE_GREEN = 0x20,
+        CMSE_IGNORE_BLUE = 0x40,
+        CMSE_IGNORE_ALPHA = 0x80,
+        // Ignore the channel when computing MSE
+
+        CMSE_IMAGE1_X2_BIAS = 0x100,
+        CMSE_IMAGE2_X2_BIAS = 0x200,
+        // Indicates that image should be scaled and biased before comparison (i.e. UNORM -> SNORM)
+    };
+
+    HRESULT __cdecl ComputeMSE(_In_ const Image& image1, _In_ const Image& image2, _Out_ float& mse, _Out_writes_opt_(4) float* mseV, _In_ CMSE_FLAGS flags = CMSE_DEFAULT) noexcept;
+
+    HRESULT __cdecl EvaluateImage(
+        _In_ const Image& image,
+        _In_ std::function<void __cdecl(_In_reads_(width) const XMVECTOR* pixels, size_t width, size_t y)> pixelFunc);
+    HRESULT __cdecl EvaluateImage(
+        _In_reads_(nimages) const Image* images, _In_ size_t nimages, _In_ const TexMetadata& metadata,
+        _In_ std::function<void __cdecl(_In_reads_(width) const XMVECTOR* pixels, size_t width, size_t y)> pixelFunc);
+
+    HRESULT __cdecl TransformImage(
+        _In_ const Image& image,
+        _In_ std::function<void __cdecl(_Out_writes_(width) XMVECTOR* outPixels,
+            _In_reads_(width) const XMVECTOR* inPixels, size_t width, size_t y)> pixelFunc,
+        ScratchImage& result);
+    HRESULT __cdecl TransformImage(
+        _In_reads_(nimages) const Image* srcImages, _In_ size_t nimages, _In_ const TexMetadata& metadata,
+        _In_ std::function<void __cdecl(_Out_writes_(width) XMVECTOR* outPixels,
+            _In_reads_(width) const XMVECTOR* inPixels, size_t width, size_t y)> pixelFunc,
+        ScratchImage& result);
+
+    //---------------------------------------------------------------------------------
+    // WIC utility code
+#ifdef _WIN32
+    enum WICCodecs
+    {
+        WIC_CODEC_BMP = 1,          // Windows Bitmap (.bmp)
+        WIC_CODEC_JPEG,             // Joint Photographic Experts Group (.jpg, .jpeg)
+        WIC_CODEC_PNG,              // Portable Network Graphics (.png)
+        WIC_CODEC_TIFF,             // Tagged Image File Format  (.tif, .tiff)
+        WIC_CODEC_GIF,              // Graphics Interchange Format  (.gif)
+        WIC_CODEC_WMP,              // Windows Media Photo / HD Photo / JPEG XR (.hdp, .jxr, .wdp)
+        WIC_CODEC_ICO,              // Windows Icon (.ico)
+        WIC_CODEC_HEIF,             // High Efficiency Image File (.heif, .heic)
+    };
+
+    REFGUID __cdecl GetWICCodec(_In_ WICCodecs codec) noexcept;
+
+    IWICImagingFactory* __cdecl GetWICFactory(bool& iswic2) noexcept;
+    void __cdecl SetWICFactory(_In_opt_ IWICImagingFactory* pWIC) noexcept;
+#endif
+
+    //---------------------------------------------------------------------------------
+    // DDS helper functions
+    HRESULT __cdecl EncodeDDSHeader(
+        _In_ const TexMetadata& metadata, DDS_FLAGS flags,
+        _Out_writes_bytes_to_opt_(maxsize, required) void* pDestination, _In_ size_t maxsize,
+        _Out_ size_t& required) noexcept;
+
+    //---------------------------------------------------------------------------------
+    // Direct3D interop
+
+    enum CREATETEX_FLAGS : uint32_t
+    {
+        CREATETEX_DEFAULT = 0,
+        CREATETEX_FORCE_SRGB = 0x1,
+        CREATETEX_IGNORE_SRGB = 0x2,
+    };
+
+    // Direct3D 11 functions
+#if defined(__d3d11_h__) || defined(__d3d11_x_h__)
+    bool __cdecl IsSupportedTexture(_In_ ID3D11Device* pDevice, _In_ const TexMetadata& metadata) noexcept;
+
+    HRESULT __cdecl CreateTexture(
+        _In_ ID3D11Device* pDevice, _In_reads_(nimages) const Image* srcImages, _In_ size_t nimages, _In_ const TexMetadata& metadata,
+        _Outptr_ ID3D11Resource** ppResource) noexcept;
+
+    HRESULT __cdecl CreateShaderResourceView(
+        _In_ ID3D11Device* pDevice, _In_reads_(nimages) const Image* srcImages, _In_ size_t nimages, _In_ const TexMetadata& metadata,
+        _Outptr_ ID3D11ShaderResourceView** ppSRV) noexcept;
+
+    HRESULT __cdecl CreateTextureEx(
+        _In_ ID3D11Device* pDevice, _In_reads_(nimages) const Image* srcImages, _In_ size_t nimages, _In_ const TexMetadata& metadata,
+        _In_ D3D11_USAGE usage, _In_ unsigned int bindFlags, _In_ unsigned int cpuAccessFlags, _In_ unsigned int miscFlags, _In_ CREATETEX_FLAGS flags,
+        _Outptr_ ID3D11Resource** ppResource) noexcept;
+
+    HRESULT __cdecl CreateShaderResourceViewEx(
+        _In_ ID3D11Device* pDevice, _In_reads_(nimages) const Image* srcImages, _In_ size_t nimages, _In_ const TexMetadata& metadata,
+        _In_ D3D11_USAGE usage, _In_ unsigned int bindFlags, _In_ unsigned int cpuAccessFlags, _In_ unsigned int miscFlags, _In_ CREATETEX_FLAGS flags,
+        _Outptr_ ID3D11ShaderResourceView** ppSRV) noexcept;
+
+    HRESULT __cdecl CaptureTexture(_In_ ID3D11Device* pDevice, _In_ ID3D11DeviceContext* pContext, _In_ ID3D11Resource* pSource, _Out_ ScratchImage& result) noexcept;
+#endif
+
+    // Direct3D 12 functions
+#if defined(__d3d12_h__) || defined(__d3d12_x_h__) || defined(__XBOX_D3D12_X__)
+    bool __cdecl IsSupportedTexture(_In_ ID3D12Device* pDevice, _In_ const TexMetadata& metadata) noexcept;
+
+    HRESULT __cdecl CreateTexture(
+        _In_ ID3D12Device* pDevice, _In_ const TexMetadata& metadata,
+        _Outptr_ ID3D12Resource** ppResource) noexcept;
+
+    HRESULT __cdecl CreateTextureEx(
+        _In_ ID3D12Device* pDevice, _In_ const TexMetadata& metadata,
+        _In_ D3D12_RESOURCE_FLAGS resFlags, _In_ CREATETEX_FLAGS flags,
+        _Outptr_ ID3D12Resource** ppResource) noexcept;
+
+    HRESULT __cdecl PrepareUpload(
+        _In_ ID3D12Device* pDevice,
+        _In_reads_(nimages) const Image* srcImages, _In_ size_t nimages, _In_ const TexMetadata& metadata,
+        std::vector<D3D12_SUBRESOURCE_DATA>& subresources);
+
+    HRESULT __cdecl CaptureTexture(
+        _In_ ID3D12CommandQueue* pCommandQueue, _In_ ID3D12Resource* pSource, _In_ bool isCubeMap,
+        _Out_ ScratchImage& result,
+        _In_ D3D12_RESOURCE_STATES beforeState = D3D12_RESOURCE_STATE_RENDER_TARGET,
+        _In_ D3D12_RESOURCE_STATES afterState = D3D12_RESOURCE_STATE_RENDER_TARGET) noexcept;
+#endif
+
+#ifdef __clang__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wcovered-switch-default"
+#pragma clang diagnostic ignored "-Wdeprecated-dynamic-exception-spec"
+#pragma clang diagnostic ignored "-Wswitch-enum"
+#endif
+
+#pragma warning(push)
+#pragma warning(disable : 4619 4616 4061)
+
+#include "DirectXTex.inl"
+
+#pragma warning(pop)
+
+#ifdef __clang__
+#pragma clang diagnostic pop
+#endif
+
+} // namespace

EscapeTheBackroomsGUiTest/vcpkg_Out/include/DirectXTex.inl

@@ -0,0 +1,213 @@
+//-------------------------------------------------------------------------------------
+// DirectXTex.inl
+//
+// DirectX Texture Library
+//
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+//
+// http://go.microsoft.com/fwlink/?LinkId=248926
+//-------------------------------------------------------------------------------------
+
+#pragma once
+
+//=====================================================================================
+// Bitmask flags enumerator operators
+//=====================================================================================
+DEFINE_ENUM_FLAG_OPERATORS(CP_FLAGS);
+DEFINE_ENUM_FLAG_OPERATORS(DDS_FLAGS);
+DEFINE_ENUM_FLAG_OPERATORS(TGA_FLAGS);
+DEFINE_ENUM_FLAG_OPERATORS(WIC_FLAGS);
+DEFINE_ENUM_FLAG_OPERATORS(TEX_FR_FLAGS);
+DEFINE_ENUM_FLAG_OPERATORS(TEX_FILTER_FLAGS);
+DEFINE_ENUM_FLAG_OPERATORS(TEX_PMALPHA_FLAGS);
+DEFINE_ENUM_FLAG_OPERATORS(TEX_COMPRESS_FLAGS);
+DEFINE_ENUM_FLAG_OPERATORS(CNMAP_FLAGS);
+DEFINE_ENUM_FLAG_OPERATORS(CMSE_FLAGS);
+DEFINE_ENUM_FLAG_OPERATORS(CREATETEX_FLAGS);
+
+// WIC_FILTER modes match TEX_FILTER modes
+constexpr WIC_FLAGS operator|(WIC_FLAGS a, TEX_FILTER_FLAGS b) { return static_cast<WIC_FLAGS>(static_cast<unsigned long>(a) | static_cast<unsigned long>(b & TEX_FILTER_MODE_MASK)); }
+constexpr WIC_FLAGS operator|(TEX_FILTER_FLAGS a, WIC_FLAGS b) { return static_cast<WIC_FLAGS>(static_cast<unsigned long>(a & TEX_FILTER_MODE_MASK) | static_cast<unsigned long>(b)); }
+
+// TEX_PMALPHA_SRGB match TEX_FILTER_SRGB
+constexpr TEX_PMALPHA_FLAGS operator|(TEX_PMALPHA_FLAGS a, TEX_FILTER_FLAGS b) { return static_cast<TEX_PMALPHA_FLAGS>(static_cast<unsigned long>(a) | static_cast<unsigned long>(b & TEX_FILTER_SRGB_MASK)); }
+constexpr TEX_PMALPHA_FLAGS operator|(TEX_FILTER_FLAGS a, TEX_PMALPHA_FLAGS b) { return static_cast<TEX_PMALPHA_FLAGS>(static_cast<unsigned long>(a & TEX_FILTER_SRGB_MASK) | static_cast<unsigned long>(b)); }
+
+// TEX_COMPRESS_SRGB match TEX_FILTER_SRGB
+constexpr TEX_COMPRESS_FLAGS operator|(TEX_COMPRESS_FLAGS a, TEX_FILTER_FLAGS b) { return static_cast<TEX_COMPRESS_FLAGS>(static_cast<unsigned long>(a) | static_cast<unsigned long>(b & TEX_FILTER_SRGB_MASK)); }
+constexpr TEX_COMPRESS_FLAGS operator|(TEX_FILTER_FLAGS a, TEX_COMPRESS_FLAGS b) { return static_cast<TEX_COMPRESS_FLAGS>(static_cast<unsigned long>(a & TEX_FILTER_SRGB_MASK) | static_cast<unsigned long>(b)); }
+
+
+//=====================================================================================
+// DXGI Format Utilities
+//=====================================================================================
+
+_Use_decl_annotations_
+constexpr bool __cdecl IsValid(DXGI_FORMAT fmt) noexcept
+{
+    return (static_cast<size_t>(fmt) >= 1 && static_cast<size_t>(fmt) <= 190);
+}
+
+_Use_decl_annotations_
+inline bool __cdecl IsCompressed(DXGI_FORMAT fmt) noexcept
+{
+    switch (fmt)
+    {
+    case DXGI_FORMAT_BC1_TYPELESS:
+    case DXGI_FORMAT_BC1_UNORM:
+    case DXGI_FORMAT_BC1_UNORM_SRGB:
+    case DXGI_FORMAT_BC2_TYPELESS:
+    case DXGI_FORMAT_BC2_UNORM:
+    case DXGI_FORMAT_BC2_UNORM_SRGB:
+    case DXGI_FORMAT_BC3_TYPELESS:
+    case DXGI_FORMAT_BC3_UNORM:
+    case DXGI_FORMAT_BC3_UNORM_SRGB:
+    case DXGI_FORMAT_BC4_TYPELESS:
+    case DXGI_FORMAT_BC4_UNORM:
+    case DXGI_FORMAT_BC4_SNORM:
+    case DXGI_FORMAT_BC5_TYPELESS:
+    case DXGI_FORMAT_BC5_UNORM:
+    case DXGI_FORMAT_BC5_SNORM:
+    case DXGI_FORMAT_BC6H_TYPELESS:
+    case DXGI_FORMAT_BC6H_UF16:
+    case DXGI_FORMAT_BC6H_SF16:
+    case DXGI_FORMAT_BC7_TYPELESS:
+    case DXGI_FORMAT_BC7_UNORM:
+    case DXGI_FORMAT_BC7_UNORM_SRGB:
+        return true;
+
+    default:
+        return false;
+    }
+}
+
+_Use_decl_annotations_
+inline bool __cdecl IsPalettized(DXGI_FORMAT fmt) noexcept
+{
+    switch (fmt)
+    {
+    case DXGI_FORMAT_AI44:
+    case DXGI_FORMAT_IA44:
+    case DXGI_FORMAT_P8:
+    case DXGI_FORMAT_A8P8:
+        return true;
+
+    default:
+        return false;
+    }
+}
+
+_Use_decl_annotations_
+inline bool __cdecl IsSRGB(DXGI_FORMAT fmt) noexcept
+{
+    switch (fmt)
+    {
+    case DXGI_FORMAT_R8G8B8A8_UNORM_SRGB:
+    case DXGI_FORMAT_BC1_UNORM_SRGB:
+    case DXGI_FORMAT_BC2_UNORM_SRGB:
+    case DXGI_FORMAT_BC3_UNORM_SRGB:
+    case DXGI_FORMAT_B8G8R8A8_UNORM_SRGB:
+    case DXGI_FORMAT_B8G8R8X8_UNORM_SRGB:
+    case DXGI_FORMAT_BC7_UNORM_SRGB:
+        return true;
+
+    default:
+        return false;
+    }
+}
+
+_Use_decl_annotations_
+inline bool __cdecl IsBGR(DXGI_FORMAT fmt) noexcept
+{
+    switch (fmt)
+    {
+    case DXGI_FORMAT_B5G6R5_UNORM:
+    case DXGI_FORMAT_B5G5R5A1_UNORM:
+    case DXGI_FORMAT_B8G8R8A8_UNORM:
+    case DXGI_FORMAT_B8G8R8X8_UNORM:
+    case DXGI_FORMAT_B8G8R8A8_TYPELESS:
+    case DXGI_FORMAT_B8G8R8A8_UNORM_SRGB:
+    case DXGI_FORMAT_B8G8R8X8_TYPELESS:
+    case DXGI_FORMAT_B8G8R8X8_UNORM_SRGB:
+    case DXGI_FORMAT_B4G4R4A4_UNORM:
+        return true;
+
+    default:
+        return false;
+    }
+}
+
+
+//=====================================================================================
+// Image I/O
+//=====================================================================================
+_Use_decl_annotations_
+inline HRESULT __cdecl SaveToDDSMemory(const Image& image, DDS_FLAGS flags, Blob& blob) noexcept
+{
+    TexMetadata mdata = {};
+    mdata.width = image.width;
+    mdata.height = image.height;
+    mdata.depth = 1;
+    mdata.arraySize = 1;
+    mdata.mipLevels = 1;
+    mdata.format = image.format;
+    mdata.dimension = TEX_DIMENSION_TEXTURE2D;
+
+    return SaveToDDSMemory(&image, 1, mdata, flags, blob);
+}
+
+_Use_decl_annotations_
+inline HRESULT __cdecl SaveToDDSFile(const Image& image, DDS_FLAGS flags, const wchar_t* szFile) noexcept
+{
+    TexMetadata mdata = {};
+    mdata.width = image.width;
+    mdata.height = image.height;
+    mdata.depth = 1;
+    mdata.arraySize = 1;
+    mdata.mipLevels = 1;
+    mdata.format = image.format;
+    mdata.dimension = TEX_DIMENSION_TEXTURE2D;
+
+    return SaveToDDSFile(&image, 1, mdata, flags, szFile);
+}
+
+
+//=====================================================================================
+// Compatability helpers
+//=====================================================================================
+_Use_decl_annotations_
+inline HRESULT __cdecl GetMetadataFromTGAMemory(const void* pSource, size_t size, TexMetadata& metadata) noexcept
+{
+    return GetMetadataFromTGAMemory(pSource, size, TGA_FLAGS_NONE, metadata);
+}
+
+_Use_decl_annotations_
+inline HRESULT __cdecl GetMetadataFromTGAFile(const wchar_t* szFile, TexMetadata& metadata) noexcept
+{
+    return GetMetadataFromTGAFile(szFile, TGA_FLAGS_NONE, metadata);
+}
+
+_Use_decl_annotations_
+inline HRESULT __cdecl LoadFromTGAMemory(const void* pSource, size_t size, TexMetadata* metadata, ScratchImage& image) noexcept
+{
+    return LoadFromTGAMemory(pSource, size, TGA_FLAGS_NONE, metadata, image);
+}
+
+_Use_decl_annotations_
+inline HRESULT __cdecl LoadFromTGAFile(const wchar_t* szFile, TexMetadata* metadata, ScratchImage& image) noexcept
+{
+    return LoadFromTGAFile(szFile, TGA_FLAGS_NONE, metadata, image);
+}
+
+_Use_decl_annotations_
+inline HRESULT __cdecl SaveToTGAMemory(const Image& image, Blob& blob, const TexMetadata* metadata) noexcept
+{
+    return SaveToTGAMemory(image, TGA_FLAGS_NONE, blob, metadata);
+}
+
+_Use_decl_annotations_
+inline HRESULT __cdecl SaveToTGAFile(const Image& image, const wchar_t* szFile, const TexMetadata* metadata) noexcept
+{
+    return SaveToTGAFile(image, TGA_FLAGS_NONE, szFile, metadata);
+}

EscapeTheBackroomsGUiTest/vcpkg_Out/include/MinHook.h

@@ -0,0 +1,186 @@
+/*
+ *  MinHook - The Minimalistic API Hooking Library for x64/x86
+ *  Copyright (C) 2009-2017 Tsuda Kageyu.
+ *  All rights reserved.
+ *
+ *  Redistribution and use in source and binary forms, with or without
+ *  modification, are permitted provided that the following conditions
+ *  are met:
+ *
+ *   1. Redistributions of source code must retain the above copyright
+ *      notice, this list of conditions and the following disclaimer.
+ *   2. Redistributions in binary form must reproduce the above copyright
+ *      notice, this list of conditions and the following disclaimer in the
+ *      documentation and/or other materials provided with the distribution.
+ *
+ *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ *  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
+ *  TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+ *  PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER
+ *  OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ *  EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ *  PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ *  PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ *  LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ *  NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ *  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#pragma once
+
+#if !(defined _M_IX86) && !(defined _M_X64) && !(defined __i386__) && !(defined __x86_64__)
+    #error MinHook supports only x86 and x64 systems.
+#endif
+
+#include <windows.h>
+
+// MinHook Error Codes.
+typedef enum MH_STATUS
+{
+    // Unknown error. Should not be returned.
+    MH_UNKNOWN = -1,
+
+    // Successful.
+    MH_OK = 0,
+
+    // MinHook is already initialized.
+    MH_ERROR_ALREADY_INITIALIZED,
+
+    // MinHook is not initialized yet, or already uninitialized.
+    MH_ERROR_NOT_INITIALIZED,
+
+    // The hook for the specified target function is already created.
+    MH_ERROR_ALREADY_CREATED,
+
+    // The hook for the specified target function is not created yet.
+    MH_ERROR_NOT_CREATED,
+
+    // The hook for the specified target function is already enabled.
+    MH_ERROR_ENABLED,
+
+    // The hook for the specified target function is not enabled yet, or already
+    // disabled.
+    MH_ERROR_DISABLED,
+
+    // The specified pointer is invalid. It points the address of non-allocated
+    // and/or non-executable region.
+    MH_ERROR_NOT_EXECUTABLE,
+
+    // The specified target function cannot be hooked.
+    MH_ERROR_UNSUPPORTED_FUNCTION,
+
+    // Failed to allocate memory.
+    MH_ERROR_MEMORY_ALLOC,
+
+    // Failed to change the memory protection.
+    MH_ERROR_MEMORY_PROTECT,
+
+    // The specified module is not loaded.
+    MH_ERROR_MODULE_NOT_FOUND,
+
+    // The specified function is not found.
+    MH_ERROR_FUNCTION_NOT_FOUND
+}
+MH_STATUS;
+
+// Can be passed as a parameter to MH_EnableHook, MH_DisableHook,
+// MH_QueueEnableHook or MH_QueueDisableHook.
+#define MH_ALL_HOOKS NULL
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+    // Initialize the MinHook library. You must call this function EXACTLY ONCE
+    // at the beginning of your program.
+    MH_STATUS WINAPI MH_Initialize(VOID);
+
+    // Uninitialize the MinHook library. You must call this function EXACTLY
+    // ONCE at the end of your program.
+    MH_STATUS WINAPI MH_Uninitialize(VOID);
+
+    // Creates a Hook for the specified target function, in disabled state.
+    // Parameters:
+    //   pTarget    [in]  A pointer to the target function, which will be
+    //                    overridden by the detour function.
+    //   pDetour    [in]  A pointer to the detour function, which will override
+    //                    the target function.
+    //   ppOriginal [out] A pointer to the trampoline function, which will be
+    //                    used to call the original target function.
+    //                    This parameter can be NULL.
+    MH_STATUS WINAPI MH_CreateHook(LPVOID pTarget, LPVOID pDetour, LPVOID *ppOriginal);
+
+    // Creates a Hook for the specified API function, in disabled state.
+    // Parameters:
+    //   pszModule  [in]  A pointer to the loaded module name which contains the
+    //                    target function.
+    //   pszTarget  [in]  A pointer to the target function name, which will be
+    //                    overridden by the detour function.
+    //   pDetour    [in]  A pointer to the detour function, which will override
+    //                    the target function.
+    //   ppOriginal [out] A pointer to the trampoline function, which will be
+    //                    used to call the original target function.
+    //                    This parameter can be NULL.
+    MH_STATUS WINAPI MH_CreateHookApi(
+        LPCWSTR pszModule, LPCSTR pszProcName, LPVOID pDetour, LPVOID *ppOriginal);
+
+    // Creates a Hook for the specified API function, in disabled state.
+    // Parameters:
+    //   pszModule  [in]  A pointer to the loaded module name which contains the
+    //                    target function.
+    //   pszTarget  [in]  A pointer to the target function name, which will be
+    //                    overridden by the detour function.
+    //   pDetour    [in]  A pointer to the detour function, which will override
+    //                    the target function.
+    //   ppOriginal [out] A pointer to the trampoline function, which will be
+    //                    used to call the original target function.
+    //                    This parameter can be NULL.
+    //   ppTarget   [out] A pointer to the target function, which will be used
+    //                    with other functions.
+    //                    This parameter can be NULL.
+    MH_STATUS WINAPI MH_CreateHookApiEx(
+        LPCWSTR pszModule, LPCSTR pszProcName, LPVOID pDetour, LPVOID *ppOriginal, LPVOID *ppTarget);
+
+    // Removes an already created hook.
+    // Parameters:
+    //   pTarget [in] A pointer to the target function.
+    MH_STATUS WINAPI MH_RemoveHook(LPVOID pTarget);
+
+    // Enables an already created hook.
+    // Parameters:
+    //   pTarget [in] A pointer to the target function.
+    //                If this parameter is MH_ALL_HOOKS, all created hooks are
+    //                enabled in one go.
+    MH_STATUS WINAPI MH_EnableHook(LPVOID pTarget);
+
+    // Disables an already created hook.
+    // Parameters:
+    //   pTarget [in] A pointer to the target function.
+    //                If this parameter is MH_ALL_HOOKS, all created hooks are
+    //                disabled in one go.
+    MH_STATUS WINAPI MH_DisableHook(LPVOID pTarget);
+
+    // Queues to enable an already created hook.
+    // Parameters:
+    //   pTarget [in] A pointer to the target function.
+    //                If this parameter is MH_ALL_HOOKS, all created hooks are
+    //                queued to be enabled.
+    MH_STATUS WINAPI MH_QueueEnableHook(LPVOID pTarget);
+
+    // Queues to disable an already created hook.
+    // Parameters:
+    //   pTarget [in] A pointer to the target function.
+    //                If this parameter is MH_ALL_HOOKS, all created hooks are
+    //                queued to be disabled.
+    MH_STATUS WINAPI MH_QueueDisableHook(LPVOID pTarget);
+
+    // Applies all queued changes in one go.
+    MH_STATUS WINAPI MH_ApplyQueued(VOID);
+
+    // Translates the MH_STATUS to its name as a string.
+    const char * WINAPI MH_StatusToString(MH_STATUS status);
+
+#ifdef __cplusplus
+}
+#endif
+

EscapeTheBackroomsGUiTest/vcpkg_Out/include/cpr/accept_encoding.h

@@ -0,0 +1,36 @@
+#ifndef CPR_ACCEPT_ENCODING_H
+#define CPR_ACCEPT_ENCODING_H
+
+#include <curl/curlver.h>
+#include <initializer_list>
+#include <map>
+#include <string>
+#include <vector>
+
+namespace cpr {
+
+enum class AcceptEncodingMethods {
+    identity,
+    deflate,
+    zlib,
+    gzip,
+};
+
+static const std::map<AcceptEncodingMethods, std::string> AcceptEncodingMethodsStringMap{{AcceptEncodingMethods::identity, "identity"}, {AcceptEncodingMethods::deflate, "deflate"}, {AcceptEncodingMethods::zlib, "zlib"}, {AcceptEncodingMethods::gzip, "gzip"}};
+
+class AcceptEncoding {
+  public:
+    AcceptEncoding() = default;
+    AcceptEncoding(const std::initializer_list<AcceptEncodingMethods>& methods);
+    AcceptEncoding(const std::initializer_list<std::string>& methods);
+
+    bool empty() const noexcept;
+    const std::string getString() const;
+
+  private:
+    std::vector<std::string> methods_;
+};
+
+} // namespace cpr
+
+#endif

EscapeTheBackroomsGUiTest/vcpkg_Out/include/cpr/api.h

@@ -0,0 +1,246 @@
+#ifndef CPR_API_H
+#define CPR_API_H
+
+#include <fstream>
+#include <functional>
+#include <future>
+#include <string>
+#include <utility>
+
+#include "cpr/async.h"
+#include "cpr/auth.h"
+#include "cpr/bearer.h"
+#include "cpr/cprtypes.h"
+#include "cpr/multipart.h"
+#include "cpr/payload.h"
+#include "cpr/response.h"
+#include "cpr/session.h"
+#include <utility>
+
+namespace cpr {
+
+using AsyncResponse = std::future<Response>;
+
+namespace priv {
+
+template <bool processed_header, typename CurrentType>
+void set_option_internal(Session& session, CurrentType&& current_option) {
+    session.SetOption(std::forward<CurrentType>(current_option));
+}
+
+template <>
+inline void set_option_internal<true, Header>(Session& session, Header&& current_option) {
+    // Header option was already provided -> Update previous header
+    session.UpdateHeader(std::forward<Header>(current_option));
+}
+
+template <bool processed_header, typename CurrentType, typename... Ts>
+void set_option_internal(Session& session, CurrentType&& current_option, Ts&&... ts) {
+    set_option_internal<processed_header, CurrentType>(session, std::forward<CurrentType>(current_option));
+
+    if (std::is_same<CurrentType, Header>::value) {
+        set_option_internal<true, Ts...>(session, std::forward<Ts>(ts)...);
+    } else {
+        set_option_internal<processed_header, Ts...>(session, std::forward<Ts>(ts)...);
+    }
+}
+
+template <typename... Ts>
+void set_option(Session& session, Ts&&... ts) {
+    set_option_internal<false, Ts...>(session, std::forward<Ts>(ts)...);
+}
+
+} // namespace priv
+
+// Get methods
+template <typename... Ts>
+Response Get(Ts&&... ts) {
+    Session session;
+    priv::set_option(session, std::forward<Ts>(ts)...);
+    return session.Get();
+}
+
+// Get async methods
+template <typename... Ts>
+AsyncResponse GetAsync(Ts... ts) {
+    return cpr::async(
+            [](Ts... ts_inner) { return Get(std::move(ts_inner)...); }, std::move(ts)...);
+}
+
+// Get callback methods
+template <typename Then, typename... Ts>
+// NOLINTNEXTLINE(fuchsia-trailing-return)
+auto GetCallback(Then then, Ts... ts) -> std::future<decltype(then(Get(std::move(ts)...)))> {
+    return cpr::async(
+            [](Then then_inner, Ts... ts_inner) { return then_inner(Get(std::move(ts_inner)...)); }, std::move(then), std::move(ts)...);
+}
+
+// Post methods
+template <typename... Ts>
+Response Post(Ts&&... ts) {
+    Session session;
+    priv::set_option(session, std::forward<Ts>(ts)...);
+    return session.Post();
+}
+
+// Post async methods
+template <typename... Ts>
+AsyncResponse PostAsync(Ts... ts) {
+    return cpr::async(
+            [](Ts... ts_inner) { return Post(std::move(ts_inner)...); }, std::move(ts)...);
+}
+
+// Post callback methods
+template <typename Then, typename... Ts>
+// NOLINTNEXTLINE(fuchsia-trailing-return)
+auto PostCallback(Then then, Ts... ts) -> std::future<decltype(then(Post(std::move(ts)...)))> {
+    return cpr::async(
+            [](Then then_inner, Ts... ts_inner) { return then_inner(Post(std::move(ts_inner)...)); }, std::move(then), std::move(ts)...);
+}
+
+// Put methods
+template <typename... Ts>
+Response Put(Ts&&... ts) {
+    Session session;
+    priv::set_option(session, std::forward<Ts>(ts)...);
+    return session.Put();
+}
+
+// Put async methods
+template <typename... Ts>
+AsyncResponse PutAsync(Ts... ts) {
+    return cpr::async(
+            [](Ts... ts_inner) { return Put(std::move(ts_inner)...); }, std::move(ts)...);
+}
+
+// Put callback methods
+template <typename Then, typename... Ts>
+// NOLINTNEXTLINE(fuchsia-trailing-return)
+auto PutCallback(Then then, Ts... ts) -> std::future<decltype(then(Put(std::move(ts)...)))> {
+    return cpr::async(
+            [](Then then_inner, Ts... ts_inner) { return then_inner(Put(std::move(ts_inner)...)); }, std::move(then), std::move(ts)...);
+}
+
+// Head methods
+template <typename... Ts>
+Response Head(Ts&&... ts) {
+    Session session;
+    priv::set_option(session, std::forward<Ts>(ts)...);
+    return session.Head();
+}
+
+// Head async methods
+template <typename... Ts>
+AsyncResponse HeadAsync(Ts... ts) {
+    return cpr::async(
+            [](Ts... ts_inner) { return Head(std::move(ts_inner)...); }, std::move(ts)...);
+}
+
+// Head callback methods
+template <typename Then, typename... Ts>
+// NOLINTNEXTLINE(fuchsia-trailing-return)
+auto HeadCallback(Then then, Ts... ts) -> std::future<decltype(then(Head(std::move(ts)...)))> {
+    return cpr::async(
+            [](Then then_inner, Ts... ts_inner) { return then_inner(Head(std::move(ts_inner)...)); }, std::move(then), std::move(ts)...);
+}
+
+// Delete methods
+template <typename... Ts>
+Response Delete(Ts&&... ts) {
+    Session session;
+    priv::set_option(session, std::forward<Ts>(ts)...);
+    return session.Delete();
+}
+
+// Delete async methods
+template <typename... Ts>
+AsyncResponse DeleteAsync(Ts... ts) {
+    return cpr::async(
+            [](Ts... ts_inner) { return Delete(std::move(ts_inner)...); }, std::move(ts)...);
+}
+
+// Delete callback methods
+template <typename Then, typename... Ts>
+// NOLINTNEXTLINE(fuchsia-trailing-return)
+auto DeleteCallback(Then then, Ts... ts) -> std::future<decltype(then(Delete(std::move(ts)...)))> {
+    return cpr::async(
+            [](Then then_inner, Ts... ts_inner) { return then_inner(Delete(std::move(ts_inner)...)); }, std::move(then), std::move(ts)...);
+}
+
+// Options methods
+template <typename... Ts>
+Response Options(Ts&&... ts) {
+    Session session;
+    priv::set_option(session, std::forward<Ts>(ts)...);
+    return session.Options();
+}
+
+// Options async methods
+template <typename... Ts>
+AsyncResponse OptionsAsync(Ts... ts) {
+    return cpr::async(
+            [](Ts... ts_inner) { return Options(std::move(ts_inner)...); }, std::move(ts)...);
+}
+
+// Options callback methods
+template <typename Then, typename... Ts>
+// NOLINTNEXTLINE(fuchsia-trailing-return)
+auto OptionsCallback(Then then, Ts... ts) -> std::future<decltype(then(Options(std::move(ts)...)))> {
+    return cpr::async(
+            [](Then then_inner, Ts... ts_inner) { return then_inner(Options(std::move(ts_inner)...)); }, std::move(then), std::move(ts)...);
+}
+
+// Patch methods
+template <typename... Ts>
+Response Patch(Ts&&... ts) {
+    Session session;
+    priv::set_option(session, std::forward<Ts>(ts)...);
+    return session.Patch();
+}
+
+// Patch async methods
+template <typename... Ts>
+AsyncResponse PatchAsync(Ts... ts) {
+    return cpr::async(
+            [](Ts... ts_inner) { return Patch(std::move(ts_inner)...); }, std::move(ts)...);
+}
+
+// Patch callback methods
+template <typename Then, typename... Ts>
+// NOLINTNEXTLINE(fuchsia-trailing-return)
+auto PatchCallback(Then then, Ts... ts) -> std::future<decltype(then(Patch(std::move(ts)...)))> {
+    return cpr::async(
+            [](Then then_inner, Ts... ts_inner) { return then_inner(Patch(std::move(ts_inner)...)); }, std::move(then), std::move(ts)...);
+}
+
+// Download methods
+template <typename... Ts>
+Response Download(std::ofstream& file, Ts&&... ts) {
+    Session session;
+    priv::set_option(session, std::forward<Ts>(ts)...);
+    return session.Download(file);
+}
+
+// Download async method
+template <typename... Ts>
+AsyncResponse DownloadAsync(std::string local_path, Ts... ts) {
+    return std::async(
+            std::launch::async,
+            [](std::string local_path, Ts... ts) {
+                std::ofstream f(local_path);
+                return Download(f, std::move(ts)...);
+            },
+            std::move(local_path), std::move(ts)...);
+}
+
+// Download with user callback
+template <typename... Ts>
+Response Download(const WriteCallback& write, Ts&&... ts) {
+    Session session;
+    priv::set_option(session, std::forward<Ts>(ts)...);
+    return session.Download(write);
+}
+
+} // namespace cpr
+
+#endif

EscapeTheBackroomsGUiTest/vcpkg_Out/include/cpr/async.h

@@ -0,0 +1,49 @@
+#ifndef CPR_ASYNC_H
+#define CPR_ASYNC_H
+
+#include "singleton.h"
+#include "threadpool.h"
+
+namespace cpr {
+
+class GlobalThreadPool : public ThreadPool {
+    CPR_SINGLETON_DECL(GlobalThreadPool)
+  protected:
+    GlobalThreadPool() = default;
+
+  public:
+    ~GlobalThreadPool() override = default;
+};
+
+/**
+ * Return a future, calling future.get() will wait task done and return RetType.
+ * async(fn, args...)
+ * async(std::bind(&Class::mem_fn, &obj))
+ * async(std::mem_fn(&Class::mem_fn, &obj))
+ **/
+template <class Fn, class... Args>
+auto async(Fn&& fn, Args&&... args) -> std::future<decltype(fn(args...))> {
+    return GlobalThreadPool::GetInstance()->Submit(std::forward<Fn>(fn), std::forward<Args>(args)...);
+}
+
+class async {
+  public:
+    static void startup(size_t min_threads = CPR_DEFAULT_THREAD_POOL_MIN_THREAD_NUM, size_t max_threads = CPR_DEFAULT_THREAD_POOL_MAX_THREAD_NUM, std::chrono::milliseconds max_idle_ms = CPR_DEFAULT_THREAD_POOL_MAX_IDLE_TIME) {
+        GlobalThreadPool* gtp = GlobalThreadPool::GetInstance();
+        if (gtp->IsStarted()) {
+            return;
+        }
+        gtp->SetMinThreadNum(min_threads);
+        gtp->SetMaxThreadNum(max_threads);
+        gtp->SetMaxIdleTime(max_idle_ms);
+        gtp->Start();
+    }
+
+    static void cleanup() {
+        GlobalThreadPool::ExitInstance();
+    }
+};
+
+} // namespace cpr
+
+#endif

EscapeTheBackroomsGUiTest/vcpkg_Out/include/cpr/auth.h

@@ -0,0 +1,33 @@
+#ifndef CPR_AUTH_H
+#define CPR_AUTH_H
+
+#include <string>
+
+#include <utility>
+
+namespace cpr {
+
+enum class AuthMode { BASIC, DIGEST, NTLM };
+
+class Authentication {
+  public:
+    Authentication(const std::string& username, const std::string& password, const AuthMode& auth_mode) : auth_string_{username + ":" + password}, auth_mode_{auth_mode} {}
+    Authentication(std::string&& username, std::string&& password, const AuthMode&& auth_mode) : auth_string_{std::move(username) + ":" + std::move(password)}, auth_mode_{std::move(auth_mode)} {}
+    Authentication(const Authentication& other) = default;
+    Authentication(Authentication&& old) noexcept = default;
+    ~Authentication() noexcept;
+
+    Authentication& operator=(Authentication&& old) noexcept = default;
+    Authentication& operator=(const Authentication& other) = default;
+
+    const char* GetAuthString() const noexcept;
+    AuthMode GetAuthMode() const noexcept;
+
+  private:
+    std::string auth_string_;
+    AuthMode auth_mode_;
+};
+
+} // namespace cpr
+
+#endif

EscapeTheBackroomsGUiTest/vcpkg_Out/include/cpr/bearer.h

@@ -0,0 +1,36 @@
+#ifndef CPR_BEARER_H
+#define CPR_BEARER_H
+
+#include <curl/curlver.h>
+#include <string>
+
+#include <utility>
+
+namespace cpr {
+
+// Only supported with libcurl >= 7.61.0.
+// As an alternative use SetHeader and add the token manually.
+#if LIBCURL_VERSION_NUM >= 0x073D00
+class Bearer {
+  public:
+    // NOLINTNEXTLINE(google-explicit-constructor, hicpp-explicit-conversions)
+    Bearer(const std::string& token) : token_string_{token} {}
+    // NOLINTNEXTLINE(google-explicit-constructor, hicpp-explicit-conversions)
+    Bearer(std::string&& token) : token_string_{std::move(token)} {}
+    Bearer(const Bearer& other) = default;
+    Bearer(Bearer&& old) noexcept = default;
+    virtual ~Bearer() noexcept;
+
+    Bearer& operator=(Bearer&& old) noexcept = default;
+    Bearer& operator=(const Bearer& other) = default;
+
+    virtual const char* GetToken() const noexcept;
+
+  protected:
+    std::string token_string_;
+};
+#endif
+
+} // namespace cpr
+
+#endif

EscapeTheBackroomsGUiTest/vcpkg_Out/include/cpr/body.h

@@ -0,0 +1,53 @@
+#ifndef CPR_BODY_H
+#define CPR_BODY_H
+
+#include <exception>
+#include <initializer_list>
+#include <string>
+#include <vector>
+#include <fstream>
+
+#include "cpr/buffer.h"
+#include "cpr/cprtypes.h"
+#include "cpr/file.h"
+
+namespace cpr {
+
+class Body : public StringHolder<Body> {
+  public:
+    Body() : StringHolder<Body>() {}
+    // NOLINTNEXTLINE(google-explicit-constructor, hicpp-explicit-conversions)
+    Body(const std::string& body) : StringHolder<Body>(body) {}
+    // NOLINTNEXTLINE(google-explicit-constructor, hicpp-explicit-conversions)
+    Body(std::string&& body) : StringHolder<Body>(std::move(body)) {}
+    // NOLINTNEXTLINE(google-explicit-constructor, hicpp-explicit-conversions)
+    Body(const char* body) : StringHolder<Body>(body) {}
+    Body(const char* str, size_t len) : StringHolder<Body>(str, len) {}
+    Body(const std::initializer_list<std::string> args) : StringHolder<Body>(args) {}
+    Body(const Buffer& buffer) : StringHolder<Body>(reinterpret_cast<const char*>(buffer.data), static_cast<size_t>(buffer.datalen)) {}
+    Body(const File& file) {
+        std::ifstream is(file.filepath, std::ifstream::binary);
+        if (is) {
+            is.seekg(0, is.end);
+            int length = is.tellg();
+            is.seekg(0, is.beg);
+            std::vector<char> buffer;
+            buffer.resize(length);
+            is.read(&buffer[0], length);
+            is.close();
+            str_ = std::string(buffer.begin(), buffer.end());
+        } else {
+            throw std::invalid_argument("Can't open the file for HTTP request body!");
+        }
+    }
+    Body(const Body& other) = default;
+    Body(Body&& old) noexcept = default;
+    ~Body() override = default;
+
+    Body& operator=(Body&& old) noexcept = default;
+    Body& operator=(const Body& other) = default;
+};
+
+} // namespace cpr
+
+#endif

EscapeTheBackroomsGUiTest/vcpkg_Out/include/cpr/buffer.h

@@ -0,0 +1,33 @@
+#ifndef CPR_BUFFER_H
+#define CPR_BUFFER_H
+
+#include <string>
+
+namespace cpr {
+
+struct Buffer {
+    using data_t = const unsigned char*;
+
+    template <typename Iterator>
+    Buffer(Iterator begin, Iterator end, std::string&& p_filename)
+            // Ignored here since libcurl reqires a long.
+            // There is also no way around the reinterpret_cast.
+            // NOLINTNEXTLINE(google-runtime-int, cppcoreguidelines-pro-type-reinterpret-cast)
+            : data{reinterpret_cast<data_t>(&(*begin))}, datalen{static_cast<long>(std::distance(begin, end))}, filename(std::move(p_filename)) {
+        is_random_access_iterator(begin, end);
+        static_assert(sizeof(*begin) == 1, "Only byte buffers can be used");
+    }
+
+    template <typename Iterator>
+    typename std::enable_if<std::is_same<typename std::iterator_traits<Iterator>::iterator_category, std::random_access_iterator_tag>::value>::type is_random_access_iterator(Iterator /* begin */, Iterator /* end */) {}
+
+    data_t data;
+    // Ignored here since libcurl reqires a long:
+    // NOLINTNEXTLINE(google-runtime-int)
+    long datalen;
+    const std::string filename;
+};
+
+} // namespace cpr
+
+#endif

EscapeTheBackroomsGUiTest/vcpkg_Out/include/cpr/callback.h

@@ -0,0 +1,89 @@
+#ifndef CPR_CALLBACK_H
+#define CPR_CALLBACK_H
+
+#include "cprtypes.h"
+
+#include <functional>
+#include <utility>
+
+namespace cpr {
+
+class ReadCallback {
+  public:
+    ReadCallback() = default;
+    // NOLINTNEXTLINE(google-explicit-constructor, hicpp-explicit-conversions)
+    ReadCallback(std::function<bool(char* buffer, size_t& size, intptr_t userdata)> p_callback, intptr_t p_userdata = 0) : userdata(p_userdata), size{-1}, callback{std::move(p_callback)} {}
+    ReadCallback(cpr_off_t p_size, std::function<bool(char* buffer, size_t& size, intptr_t userdata)> p_callback, intptr_t p_userdata = 0) : userdata(p_userdata), size{p_size}, callback{std::move(p_callback)} {}
+    bool operator()(char* buffer, size_t& buffer_size) const {
+        return callback(buffer, buffer_size, userdata);
+    }
+
+    intptr_t userdata;
+    cpr_off_t size{};
+    std::function<bool(char* buffer, size_t& size, intptr_t userdata)> callback;
+};
+
+class HeaderCallback {
+  public:
+    HeaderCallback() = default;
+    // NOLINTNEXTLINE(google-explicit-constructor, hicpp-explicit-conversions)
+    HeaderCallback(std::function<bool(std::string header, intptr_t userdata)> p_callback, intptr_t p_userdata = 0) : userdata(p_userdata), callback(std::move(p_callback)) {}
+    bool operator()(std::string header) const {
+        return callback(std::move(header), userdata);
+    }
+
+    intptr_t userdata;
+    std::function<bool(std::string header, intptr_t userdata)> callback;
+};
+
+class WriteCallback {
+  public:
+    WriteCallback() = default;
+    // NOLINTNEXTLINE(google-explicit-constructor, hicpp-explicit-conversions)
+    WriteCallback(std::function<bool(std::string data, intptr_t userdata)> p_callback, intptr_t p_userdata = 0) : userdata(p_userdata), callback(std::move(p_callback)) {}
+    bool operator()(std::string data) const {
+        return callback(std::move(data), userdata);
+    }
+
+    intptr_t userdata;
+    std::function<bool(std::string data, intptr_t userdata)> callback;
+};
+
+class ProgressCallback {
+  public:
+    ProgressCallback() = default;
+    // NOLINTNEXTLINE(google-explicit-constructor, hicpp-explicit-conversions)
+    ProgressCallback(std::function<bool(cpr_off_t downloadTotal, cpr_off_t downloadNow, cpr_off_t uploadTotal, cpr_off_t uploadNow, intptr_t userdata)> p_callback, intptr_t p_userdata = 0) : userdata(p_userdata), callback(std::move(p_callback)) {}
+    bool operator()(cpr_off_t downloadTotal, cpr_off_t downloadNow, cpr_off_t uploadTotal, cpr_off_t uploadNow) const {
+        return callback(downloadTotal, downloadNow, uploadTotal, uploadNow, userdata);
+    }
+
+    intptr_t userdata;
+    std::function<bool(cpr_off_t downloadTotal, cpr_off_t downloadNow, cpr_off_t uploadTotal, cpr_off_t uploadNow, intptr_t userdata)> callback;
+};
+
+class DebugCallback {
+  public:
+    enum class InfoType {
+        TEXT = 0,
+        HEADER_IN = 1,
+        HEADER_OUT = 2,
+        DATA_IN = 3,
+        DATA_OUT = 4,
+        SSL_DATA_IN = 5,
+        SSL_DATA_OUT = 6,
+    };
+    DebugCallback() = default;
+    // NOLINTNEXTLINE(google-explicit-constructor, hicpp-explicit-conversions)
+    DebugCallback(std::function<void(InfoType type, std::string data, intptr_t userdata)> p_callback, intptr_t p_userdata = 0) : userdata(p_userdata), callback(std::move(p_callback)) {}
+    void operator()(InfoType type, std::string data) const {
+        callback(type, std::move(data), userdata);
+    }
+
+    intptr_t userdata;
+    std::function<void(InfoType type, std::string data, intptr_t userdata)> callback;
+};
+
+} // namespace cpr
+
+#endif

EscapeTheBackroomsGUiTest/vcpkg_Out/include/cpr/cert_info.h

@@ -0,0 +1,35 @@
+#ifndef CPR_CERT_INFO_H
+#define CPR_CERT_INFO_H
+
+#include <initializer_list>
+#include <string>
+#include <vector>
+
+namespace cpr {
+
+class CertInfo {
+  private:
+    std::vector<std::string> cert_info_;
+
+  public:
+    CertInfo() = default;
+    CertInfo(const std::initializer_list<std::string>& entry) : cert_info_{entry} {};
+    ~CertInfo() noexcept = default;
+
+    using iterator = std::vector<std::string>::iterator;
+    using const_iterator = std::vector<std::string>::const_iterator;
+
+    std::string& operator[](const size_t& pos);
+    iterator begin();
+    iterator end();
+    const_iterator begin() const;
+    const_iterator end() const;
+    const_iterator cbegin() const;
+    const_iterator cend() const;
+    void emplace_back(const std::string& str);
+    void push_back(const std::string& str);
+    void pop_back();
+};
+} // namespace cpr
+
+#endif

EscapeTheBackroomsGUiTest/vcpkg_Out/include/cpr/connect_timeout.h

@@ -0,0 +1,18 @@
+#ifndef CPR_CONNECT_TIMEOUT_H
+#define CPR_CONNECT_TIMEOUT_H
+
+#include "cpr/timeout.h"
+
+namespace cpr {
+
+class ConnectTimeout : public Timeout {
+  public:
+    // NOLINTNEXTLINE(google-explicit-constructor, hicpp-explicit-conversions)
+    ConnectTimeout(const std::chrono::milliseconds& duration) : Timeout{duration} {}
+    // NOLINTNEXTLINE(google-explicit-constructor, hicpp-explicit-conversions)
+    ConnectTimeout(const std::int32_t& milliseconds) : Timeout{milliseconds} {}
+};
+
+} // namespace cpr
+
+#endif

EscapeTheBackroomsGUiTest/vcpkg_Out/include/cpr/cookies.h

@@ -0,0 +1,92 @@
+#ifndef CPR_COOKIES_H
+#define CPR_COOKIES_H
+
+#include "cpr/curlholder.h"
+#include <chrono>
+#include <initializer_list>
+#include <sstream>
+#include <string>
+#include <vector>
+
+namespace cpr {
+/**
+ * EXPIRES_STRING_SIZE is an explicitly static and const variable that could be only accessed within the same namespace and is immutable.
+ * To be used for "std::array", the expression must have a constant value, so EXPIRES_STRING_SIZE must be a const value.
+ **/
+static const std::size_t EXPIRES_STRING_SIZE = 100;
+
+class Cookie {
+  public:
+    Cookie() = default;
+    /**
+     * Some notes for the default value used by expires:
+     * std::chrono::system_clock::time_point::min() won't work on Windows due to the min, max clash there.
+     * So we fall back to std::chrono::system_clock::from_time_t(0) for the minimum value here.
+     **/
+    Cookie(const std::string& name, const std::string& value, const std::string& domain = "", bool p_isIncludingSubdomains = false, const std::string& path = "/", bool p_isHttpsOnly = false, std::chrono::system_clock::time_point expires = std::chrono::system_clock::from_time_t(0)) : name_{name}, value_{value}, domain_{domain}, includeSubdomains_{p_isIncludingSubdomains}, path_{path}, httpsOnly_{p_isHttpsOnly}, expires_{expires} {};
+    const std::string GetDomain() const;
+    bool IsIncludingSubdomains() const;
+    const std::string GetPath() const;
+    bool IsHttpsOnly() const;
+    const std::chrono::system_clock::time_point GetExpires() const;
+    const std::string GetExpiresString() const;
+    const std::string GetName() const;
+    const std::string GetValue() const;
+
+  private:
+    std::string name_;
+    std::string value_;
+    std::string domain_;
+    bool includeSubdomains_{};
+    std::string path_;
+    bool httpsOnly_{};
+    /**
+     * TODO: Update the implementation using `std::chrono::utc_clock` of C++20
+     **/
+    std::chrono::system_clock::time_point expires_{};
+};
+
+class Cookies {
+  public:
+    /**
+     * Should we URL-encode cookies when making a request.
+     * Based on RFC6265, it is recommended but not mandatory to encode cookies.
+     *
+     * -------
+     * To maximize compatibility with user agents, servers that wish to
+     * store arbitrary data in a cookie-value SHOULD encode that data, for
+     * example, using Base64 [RFC4648].
+     * -------
+     * Source: RFC6265 (https://www.ietf.org/rfc/rfc6265.txt)
+     **/
+    bool encode{true};
+
+    // NOLINTNEXTLINE(google-explicit-constructor, hicpp-explicit-conversions)
+    Cookies(bool p_encode = true) : encode{p_encode} {};
+    Cookies(const std::initializer_list<cpr::Cookie>& cookies, bool p_encode = true) : encode{p_encode}, cookies_{cookies} {};
+    // NOLINTNEXTLINE(google-explicit-constructor, hicpp-explicit-conversions)
+    Cookies(const cpr::Cookie& cookie, bool p_encode = true) : encode{p_encode}, cookies_{cookie} {};
+
+    cpr::Cookie& operator[](size_t pos);
+    const std::string GetEncoded(const CurlHolder& holder) const;
+
+    using iterator = std::vector<cpr::Cookie>::iterator;
+    using const_iterator = std::vector<cpr::Cookie>::const_iterator;
+
+    iterator begin();
+    iterator end();
+    const_iterator begin() const;
+    const_iterator end() const;
+    const_iterator cbegin() const;
+    const_iterator cend() const;
+    void emplace_back(const Cookie& str);
+    void push_back(const Cookie& str);
+    void pop_back();
+
+  private:
+    std::vector<cpr::Cookie> cookies_;
+};
+
+} // namespace cpr
+
+#endif

EscapeTheBackroomsGUiTest/vcpkg_Out/include/cpr/cpr.h

@@ -0,0 +1,44 @@
+#ifndef CPR_CPR_H
+#define CPR_CPR_H
+
+#include "cpr/api.h"
+#include "cpr/auth.h"
+#include "cpr/bearer.h"
+#include "cpr/callback.h"
+#include "cpr/cert_info.h"
+#include "cpr/connect_timeout.h"
+#include "cpr/cookies.h"
+#include "cpr/cprtypes.h"
+#include "cpr/cprver.h"
+#include "cpr/curl_container.h"
+#include "cpr/curlholder.h"
+#include "cpr/error.h"
+#include "cpr/http_version.h"
+#include "cpr/interceptor.h"
+#include "cpr/interface.h"
+#include "cpr/limit_rate.h"
+#include "cpr/local_port.h"
+#include "cpr/local_port_range.h"
+#include "cpr/low_speed.h"
+#include "cpr/multipart.h"
+#include "cpr/parameters.h"
+#include "cpr/payload.h"
+#include "cpr/proxies.h"
+#include "cpr/proxyauth.h"
+#include "cpr/range.h"
+#include "cpr/redirect.h"
+#include "cpr/reserve_size.h"
+#include "cpr/response.h"
+#include "cpr/session.h"
+#include "cpr/ssl_ctx.h"
+#include "cpr/ssl_options.h"
+#include "cpr/status_codes.h"
+#include "cpr/timeout.h"
+#include "cpr/unix_socket.h"
+#include "cpr/user_agent.h"
+#include "cpr/util.h"
+#include "cpr/verbose.h"
+
+#define CPR_LIBCURL_VERSION_NUM LIBCURL_VERSION_NUM
+
+#endif

EscapeTheBackroomsGUiTest/vcpkg_Out/include/cpr/cprtypes.h

@@ -0,0 +1,133 @@
+#ifndef CPR_CPR_TYPES_H
+#define CPR_CPR_TYPES_H
+
+#include <curl/system.h>
+#include <initializer_list>
+#include <map>
+#include <memory>
+#include <numeric>
+#include <string>
+
+namespace cpr {
+
+/**
+ * Wrapper around "curl_off_t" to prevent applications from having to link against libcurl.
+ **/
+using cpr_off_t = curl_off_t;
+
+template <class T>
+class StringHolder {
+  public:
+    StringHolder() = default;
+    explicit StringHolder(const std::string& str) : str_(str) {}
+    explicit StringHolder(std::string&& str) : str_(std::move(str)) {}
+    explicit StringHolder(const char* str) : str_(str) {}
+    StringHolder(const char* str, size_t len) : str_(str, len) {}
+    StringHolder(const std::initializer_list<std::string> args) {
+        str_ = std::accumulate(args.begin(), args.end(), str_);
+    }
+    StringHolder(const StringHolder& other) = default;
+    StringHolder(StringHolder&& old) noexcept = default;
+    virtual ~StringHolder() = default;
+
+    StringHolder& operator=(StringHolder&& old) noexcept = default;
+
+    StringHolder& operator=(const StringHolder& other) = default;
+
+    explicit operator std::string() const {
+        return str_;
+    }
+
+    T operator+(const char* rhs) const {
+        return T(str_ + rhs);
+    }
+
+    T operator+(const std::string& rhs) const {
+        return T(str_ + rhs);
+    }
+
+    T operator+(const StringHolder<T>& rhs) const {
+        return T(str_ + rhs.str_);
+    }
+
+    void operator+=(const char* rhs) {
+        str_ += rhs;
+    }
+    void operator+=(const std::string& rhs) {
+        str_ += rhs;
+    }
+    void operator+=(const StringHolder<T>& rhs) {
+        str_ += rhs;
+    }
+
+    bool operator==(const char* rhs) const {
+        return str_ == rhs;
+    }
+    bool operator==(const std::string& rhs) const {
+        return str_ == rhs;
+    }
+    bool operator==(const StringHolder<T>& rhs) const {
+        return str_ == rhs.str_;
+    }
+
+    bool operator!=(const char* rhs) const {
+        return str_.c_str() != rhs;
+    }
+    bool operator!=(const std::string& rhs) const {
+        return str_ != rhs;
+    }
+    bool operator!=(const StringHolder<T>& rhs) const {
+        return str_ != rhs.str_;
+    }
+
+    const std::string& str() {
+        return str_;
+    }
+    const std::string& str() const {
+        return str_;
+    }
+    const char* c_str() const {
+        return str_.c_str();
+    }
+    const char* data() const {
+        return str_.data();
+    }
+
+  protected:
+    std::string str_{};
+};
+
+template <class T>
+std::ostream& operator<<(std::ostream& os, const StringHolder<T>& s) {
+    os << s.str();
+    return os;
+}
+
+class Url : public StringHolder<Url> {
+  public:
+    Url() = default;
+    // NOLINTNEXTLINE(google-explicit-constructor, hicpp-explicit-conversions)
+    Url(const std::string& url) : StringHolder<Url>(url) {}
+    // NOLINTNEXTLINE(google-explicit-constructor, hicpp-explicit-conversions)
+    Url(std::string&& url) : StringHolder<Url>(std::move(url)) {}
+    // NOLINTNEXTLINE(google-explicit-constructor, hicpp-explicit-conversions)
+    Url(const char* url) : StringHolder<Url>(url) {}
+    Url(const char* str, size_t len) : StringHolder<Url>(std::string(str, len)) {}
+    Url(const std::initializer_list<std::string> args) : StringHolder<Url>(args) {}
+    Url(const Url& other) = default;
+    Url(Url&& old) noexcept = default;
+    ~Url() override = default;
+
+    Url& operator=(Url&& old) noexcept = default;
+    Url& operator=(const Url& other) = default;
+};
+
+struct CaseInsensitiveCompare {
+    bool operator()(const std::string& a, const std::string& b) const noexcept;
+};
+
+using Header = std::map<std::string, std::string, CaseInsensitiveCompare>;
+
+} // namespace cpr
+
+#endif

EscapeTheBackroomsGUiTest/vcpkg_Out/include/cpr/cprver.h

@@ -0,0 +1,30 @@
+#ifndef CPR_CPRVER_H
+#define CPR_CPRVER_H
+
+/**
+ * CPR version as a string.
+ **/
+#define CPR_VERSION "1.9.2"
+
+/**
+ * CPR version split up into parts.
+ **/
+#define CPR_VERSION_MAJOR 1
+#define CPR_VERSION_MINOR 9
+#define CPR_VERSION_PATCH 2
+
+/**
+ * CPR version as a single hex digit.
+ * it can be split up into three parts:
+ * 0xAABBCC
+ * AA: The current CPR major version number in a hex format.
+ * BB: The current CPR minor version number in a hex format.
+ * CC: The current CPR patch version number in a hex format.
+ *
+ * Examples:
+ * '0x010702' -> 01.07.02 -> CPR_VERSION: 1.7.2
+ * '0xA13722' -> A1.37.22 -> CPR_VERSION: 161.55.34
+ **/
+#define CPR_VERSION_NUM 0x10902
+
+#endif

EscapeTheBackroomsGUiTest/vcpkg_Out/include/cpr/curl_container.h

@@ -0,0 +1,53 @@
+#ifndef CURL_CONTAINER_H
+#define CURL_CONTAINER_H
+
+#include <initializer_list>
+#include <memory>
+#include <string>
+#include <vector>
+
+#include "cpr/curlholder.h"
+
+
+namespace cpr {
+
+struct Parameter {
+    Parameter(const std::string& p_key, const std::string& p_value) : key{p_key}, value{p_value} {}
+    Parameter(std::string&& p_key, std::string&& p_value) : key{std::move(p_key)}, value{std::move(p_value)} {}
+
+    std::string key;
+    std::string value;
+};
+
+struct Pair {
+    Pair(const std::string& p_key, const std::string& p_value) : key(p_key), value(p_value) {}
+    Pair(std::string&& p_key, std::string&& p_value) : key(std::move(p_key)), value(std::move(p_value)) {}
+
+    std::string key;
+    std::string value;
+};
+
+
+template <class T>
+class CurlContainer {
+  public:
+    /**
+     * Enables or disables URL encoding for keys and values when calling GetContent(...).
+     **/
+    bool encode = true;
+
+    CurlContainer() = default;
+    CurlContainer(const std::initializer_list<T>&);
+
+    void Add(const std::initializer_list<T>&);
+    void Add(const T&);
+
+    const std::string GetContent(const CurlHolder&) const;
+
+  protected:
+    std::vector<T> containerList_;
+};
+
+} // namespace cpr
+
+#endif //

EscapeTheBackroomsGUiTest/vcpkg_Out/include/cpr/curlholder.h

@@ -0,0 +1,53 @@
+#ifndef CPR_CURL_HOLDER_H
+#define CPR_CURL_HOLDER_H
+
+#include <array>
+#include <mutex>
+#include <string>
+
+#include <curl/curl.h>
+
+namespace cpr {
+struct CurlHolder {
+  private:
+    /**
+     * Mutex for curl_easy_init().
+     * curl_easy_init() is not thread save.
+     * References:
+     * https://curl.haxx.se/libcurl/c/curl_easy_init.html
+     * https://curl.haxx.se/libcurl/c/threadsafe.html
+     **/
+
+    // Avoids initalization order problems in a static build
+    static std::mutex& curl_easy_init_mutex_() {
+        static std::mutex curl_easy_init_mutex_;
+        return curl_easy_init_mutex_;
+    }
+
+  public:
+    CURL* handle{nullptr};
+    struct curl_slist* chunk{nullptr};
+    struct curl_httppost* formpost{nullptr};
+    std::array<char, CURL_ERROR_SIZE> error{};
+
+    CurlHolder();
+    CurlHolder(const CurlHolder& other) = default;
+    CurlHolder(CurlHolder&& old) noexcept = default;
+    ~CurlHolder();
+
+    CurlHolder& operator=(CurlHolder&& old) noexcept = default;
+    CurlHolder& operator=(const CurlHolder& other) = default;
+
+    /**
+     * Uses curl_easy_escape(...) for escaping the given string.
+     **/
+    std::string urlEncode(const std::string& s) const;
+
+    /**
+     * Uses curl_easy_unescape(...) for unescaping the given string.
+     **/
+    std::string urlDecode(const std::string& s) const;
+};
+} // namespace cpr
+
+#endif

EscapeTheBackroomsGUiTest/vcpkg_Out/include/cpr/error.h

@@ -0,0 +1,53 @@
+#ifndef CPR_ERROR_H
+#define CPR_ERROR_H
+
+#include <cstdint>
+#include <string>
+
+#include "cpr/cprtypes.h"
+#include <utility>
+
+namespace cpr {
+
+enum class ErrorCode {
+    OK = 0,
+    CONNECTION_FAILURE,
+    EMPTY_RESPONSE,
+    HOST_RESOLUTION_FAILURE,
+    INTERNAL_ERROR,
+    INVALID_URL_FORMAT,
+    NETWORK_RECEIVE_ERROR,
+    NETWORK_SEND_FAILURE,
+    OPERATION_TIMEDOUT,
+    PROXY_RESOLUTION_FAILURE,
+    SSL_CONNECT_ERROR,
+    SSL_LOCAL_CERTIFICATE_ERROR,
+    SSL_REMOTE_CERTIFICATE_ERROR,
+    SSL_CACERT_ERROR,
+    GENERIC_SSL_ERROR,
+    UNSUPPORTED_PROTOCOL,
+    REQUEST_CANCELLED,
+    TOO_MANY_REDIRECTS,
+    UNKNOWN_ERROR = 1000,
+};
+
+class Error {
+  public:
+    ErrorCode code = ErrorCode::OK;
+    std::string message{};
+
+    Error() = default;
+
+    Error(const std::int32_t& curl_code, std::string&& p_error_message) : code{getErrorCodeForCurlError(curl_code)}, message(std::move(p_error_message)) {}
+
+    explicit operator bool() const {
+        return code != ErrorCode::OK;
+    }
+
+  private:
+    static ErrorCode getErrorCodeForCurlError(std::int32_t curl_code);
+};
+
+} // namespace cpr
+
+#endif

EscapeTheBackroomsGUiTest/vcpkg_Out/include/cpr/file.h

@@ -0,0 +1,16 @@
+#ifndef CPR_FILE_H
+#define CPR_FILE_H
+
+#include <string>
+
+namespace cpr {
+
+struct File {
+    explicit File(std::string&& p_filepath) : filepath(std::move(p_filepath)) {}
+    explicit File(const std::string& p_filepath) : filepath(p_filepath) {}
+    const std::string filepath;
+};
+
+} // namespace cpr
+
+#endif

EscapeTheBackroomsGUiTest/vcpkg_Out/include/cpr/http_version.h

@@ -0,0 +1,67 @@
+#ifndef CPR_HTTP_VERSION_H
+#define CPR_HTTP_VERSION_H
+
+#include <curl/curlver.h>
+
+namespace cpr {
+enum class HttpVersionCode {
+    /**
+     * Let libcurl decide which version is the best.
+     **/
+    VERSION_NONE,
+    /**
+     * Enforce HTTP 1.0 requests.
+     **/
+    VERSION_1_0,
+    /**
+     * Enforce HTTP 1.1 requests.
+     **/
+    VERSION_1_1,
+#if LIBCURL_VERSION_NUM >= 0x072100 // 7.33.0
+    /**
+     * Attempt HTTP 2.0 requests.
+     * Fallback to HTTP 1.1 if negotiation fails.
+     **/
+    VERSION_2_0,
+#endif
+#if LIBCURL_VERSION_NUM >= 0x072F00 // 7.47.0
+    /**
+     * Attempt HTTP 2.0 for HTTPS requests only.
+     * Fallback to HTTP 1.1 if negotiation fails.
+     * HTTP 1.1 will be used for HTTP connections.
+     **/
+    VERSION_2_0_TLS,
+#endif
+#if LIBCURL_VERSION_NUM >= 0x073100 // 7.49.0
+    /**
+     * Start HTTP 2.0 for HTTP requests.
+     * Requires prior knowledge that the server supports HTTP 2.0.
+     * For HTTPS requests we will negotiate the protocol version in the TLS handshake.
+     **/
+    VERSION_2_0_PRIOR_KNOWLEDGE,
+#endif
+#if LIBCURL_VERSION_NUM >= 0x074200 // 7.66.0
+    /**
+     * Attempt HTTP 3.0 requests.
+     * Requires prior knowledge that the server supports HTTP 3.0 since there is no gracefully downgrade.
+     * Fallback to HTTP 1.1 if negotiation fails.
+     **/
+    VERSION_3_0
+#endif
+};
+
+class HttpVersion {
+  public:
+    /**
+     * The HTTP version that should be used by libcurl when initiating a HTTP(S) connection.
+     * Default: HttpVersionCode::VERSION_NONE
+     **/
+    HttpVersionCode code = HttpVersionCode::VERSION_NONE;
+
+    HttpVersion() = default;
+    explicit HttpVersion(HttpVersionCode _code) : code(_code) {}
+};
+
+} // namespace cpr
+
+#endif

EscapeTheBackroomsGUiTest/vcpkg_Out/include/cpr/interceptor.h

@@ -0,0 +1,36 @@
+#ifndef CPR_INTERCEPTOR_H
+#define CPR_INTERCEPTOR_H
+
+#include "cpr/response.h"
+#include "cpr/session.h"
+
+namespace cpr {
+
+class Interceptor {
+  public:
+    enum class ProceedHttpMethod {
+        GET_REQUEST = 0,
+        POST_REQUEST,
+        PUT_REQUEST,
+        DELETE_REQUEST,
+        PATCH_REQUEST,
+        HEAD_REQUEST,
+        OPTIONS_REQUEST,
+        DOWNLOAD_CALLBACK_REQUEST,
+        DOWNLOAD_FILE_REQUEST,
+    };
+
+    virtual ~Interceptor() = default;
+    virtual Response intercept(Session& session) = 0;
+
+  protected:
+    static Response proceed(Session& session);
+    static Response proceed(Session& session, ProceedHttpMethod httpMethod);
+    static Response proceed(Session& session, ProceedHttpMethod httpMethod, std::ofstream& file);
+    static Response proceed(Session& session, ProceedHttpMethod httpMethod, const WriteCallback& write);
+};
+
+} // namespace cpr
+
+
+#endif

EscapeTheBackroomsGUiTest/vcpkg_Out/include/cpr/interface.h

@@ -0,0 +1,32 @@
+#ifndef CPR_INTERFACE_H
+#define CPR_INTERFACE_H
+
+#include <initializer_list>
+#include <string>
+
+#include "cpr/cprtypes.h"
+
+namespace cpr {
+
+class Interface : public StringHolder<Interface> {
+  public:
+    Interface() : StringHolder<Interface>() {}
+    // NOLINTNEXTLINE(google-explicit-constructor, hicpp-explicit-conversions)
+    Interface(const std::string& iface) : StringHolder<Interface>(iface) {}
+    // NOLINTNEXTLINE(google-explicit-constructor, hicpp-explicit-conversions)
+    Interface(std::string&& iface) : StringHolder<Interface>(std::move(iface)) {}
+    // NOLINTNEXTLINE(google-explicit-constructor, hicpp-explicit-conversions)
+    Interface(const char* iface) : StringHolder<Interface>(iface) {}
+    Interface(const char* str, size_t len) : StringHolder<Interface>(str, len) {}
+    Interface(const std::initializer_list<std::string> args) : StringHolder<Interface>(args) {}
+    Interface(const Interface& other) = default;
+    Interface(Interface&& old) noexcept = default;
+    ~Interface() override = default;
+
+    Interface& operator=(Interface&& old) noexcept = default;
+    Interface& operator=(const Interface& other) = default;
+};
+
+} // namespace cpr
+
+#endif

EscapeTheBackroomsGUiTest/vcpkg_Out/include/cpr/limit_rate.h

@@ -0,0 +1,18 @@
+#ifndef CPR_SPEED_LIMIT_H
+#define CPR_SPEED_LIMIT_H
+
+#include <cstdint>
+
+namespace cpr {
+
+class LimitRate {
+  public:
+    LimitRate(const std::int64_t p_downrate, const std::int64_t p_uprate) : downrate(p_downrate), uprate(p_uprate) {}
+
+    std::int64_t downrate = 0;
+    std::int64_t uprate = 0;
+};
+
+} // namespace cpr
+
+#endif

EscapeTheBackroomsGUiTest/vcpkg_Out/include/cpr/local_port.h

@@ -0,0 +1,23 @@
+#ifndef CPR_LOCAL_PORT_H
+#define CPR_LOCAL_PORT_H
+
+#include <cstdint>
+
+namespace cpr {
+
+class LocalPort {
+  public:
+    // NOLINTNEXTLINE(google-explicit-constructor)
+    LocalPort(const std::uint16_t p_localport) : localport_(p_localport) {}
+
+    operator std::uint16_t() const {
+        return localport_;
+    }
+
+  private:
+    std::uint16_t localport_ = 0;
+};
+
+} // namespace cpr
+
+#endif

EscapeTheBackroomsGUiTest/vcpkg_Out/include/cpr/local_port_range.h

@@ -0,0 +1,23 @@
+#ifndef CPR_LOCAL_PORT_RANGE_H
+#define CPR_LOCAL_PORT_RANGE_H
+
+#include <cstdint>
+
+namespace cpr {
+
+class LocalPortRange {
+  public:
+    // NOLINTNEXTLINE(google-explicit-constructor)
+    LocalPortRange(const std::uint16_t p_localportrange) : localportrange_(p_localportrange) {}
+
+    operator std::uint16_t() const {
+        return localportrange_;
+    }
+
+  private:
+    std::uint16_t localportrange_ = 0;
+};
+
+} // namespace cpr
+
+#endif

EscapeTheBackroomsGUiTest/vcpkg_Out/include/cpr/low_speed.h

@@ -0,0 +1,18 @@
+#ifndef CPR_LOW_SPEED_H
+#define CPR_LOW_SPEED_H
+
+#include <cstdint>
+
+namespace cpr {
+
+class LowSpeed {
+  public:
+    LowSpeed(const std::int32_t p_limit, const std::int32_t p_time) : limit(p_limit), time(p_time) {}
+
+    std::int32_t limit;
+    std::int32_t time;
+};
+
+} // namespace cpr
+
+#endif

EscapeTheBackroomsGUiTest/vcpkg_Out/include/cpr/multipart.h

@@ -0,0 +1,44 @@
+#ifndef CPR_MULTIPART_H
+#define CPR_MULTIPART_H
+
+#include <cstdint>
+#include <initializer_list>
+#include <string>
+#include <type_traits>
+#include <vector>
+
+#include "buffer.h"
+#include "file.h"
+
+namespace cpr {
+
+struct Part {
+    Part(const std::string& p_name, const std::string& p_value, const std::string& p_content_type = {}) : name{p_name}, value{p_value}, content_type{p_content_type}, is_file{false}, is_buffer{false}, has_filename{false} {}
+    Part(const std::string& p_name, const std::int32_t& p_value, const std::string& p_content_type = {}) : name{p_name}, value{std::to_string(p_value)}, content_type{p_content_type}, is_file{false}, is_buffer{false}, has_filename{false} {}
+    Part(const std::string& p_name, const File& file, const std::string& p_content_type = {}) : name{p_name}, value{file.filepath}, content_type{p_content_type}, is_file{true}, is_buffer{false}, has_filename{false} {}
+    Part(const std::string& p_name, const std::string& p_filename, const File& file, const std::string& p_content_type = {}) : name{p_name}, filename{p_filename}, value{file.filepath}, content_type{p_content_type}, is_file{true}, is_buffer{false}, has_filename{true} {}
+    Part(const std::string& p_name, const Buffer& buffer, const std::string& p_content_type = {}) : name{p_name}, value{buffer.filename}, content_type{p_content_type}, data{buffer.data}, datalen{buffer.datalen}, is_file{false}, is_buffer{true}, has_filename{false} {}
+
+    std::string name;
+    std::string filename;
+    std::string value;
+    std::string content_type;
+    Buffer::data_t data{nullptr};
+    // Ignored here since libcurl reqires a long:
+    // NOLINTNEXTLINE(google-runtime-int)
+    long datalen{0};
+    bool is_file;
+    bool is_buffer;
+    bool has_filename;
+};
+
+class Multipart {
+  public:
+    Multipart(const std::initializer_list<Part>& parts);
+
+    std::vector<Part> parts;
+};
+
+} // namespace cpr
+
+#endif

EscapeTheBackroomsGUiTest/vcpkg_Out/include/cpr/parameters.h

@@ -0,0 +1,18 @@
+#ifndef CPR_PARAMETERS_H
+#define CPR_PARAMETERS_H
+
+#include <initializer_list>
+
+#include "cpr/curl_container.h"
+
+namespace cpr {
+
+class Parameters : public CurlContainer<Parameter> {
+  public:
+    Parameters() = default;
+    Parameters(const std::initializer_list<Parameter>& parameters);
+};
+
+} // namespace cpr
+
+#endif

EscapeTheBackroomsGUiTest/vcpkg_Out/include/cpr/payload.h

@@ -0,0 +1,23 @@
+#ifndef CPR_PAYLOAD_H
+#define CPR_PAYLOAD_H
+
+#include <initializer_list>
+
+#include "cpr/curl_container.h"
+
+
+namespace cpr {
+class Payload : public CurlContainer<Pair> {
+  public:
+    template <class It>
+    Payload(const It begin, const It end) {
+        for (It pair = begin; pair != end; ++pair) {
+            Add(*pair);
+        }
+    }
+    Payload(const std::initializer_list<Pair>& pairs);
+};
+
+} // namespace cpr
+
+#endif

EscapeTheBackroomsGUiTest/vcpkg_Out/include/cpr/proxies.h

@@ -0,0 +1,23 @@
+#ifndef CPR_PROXIES_H
+#define CPR_PROXIES_H
+
+#include <initializer_list>
+#include <map>
+#include <string>
+
+namespace cpr {
+class Proxies {
+  public:
+    Proxies() = default;
+    Proxies(const std::initializer_list<std::pair<const std::string, std::string>>& hosts);
+    Proxies(const std::map<std::string, std::string>& hosts);
+
+    bool has(const std::string& protocol) const;
+    const std::string& operator[](const std::string& protocol);
+
+  private:
+    std::map<std::string, std::string> hosts_;
+};
+} // namespace cpr
+
+#endif

EscapeTheBackroomsGUiTest/vcpkg_Out/include/cpr/proxyauth.h

@@ -0,0 +1,44 @@
+#ifndef CPR_PROXYAUTH_H
+#define CPR_PROXYAUTH_H
+
+#include <initializer_list>
+#include <map>
+
+#include "cpr/auth.h"
+#include "cpr/util.h"
+
+namespace cpr {
+class EncodedAuthentication {
+  public:
+    EncodedAuthentication() : auth_string_{""} {}
+    EncodedAuthentication(const std::string& username, const std::string& password) : auth_string_{cpr::util::urlEncode(username) + ":" + cpr::util::urlEncode(password)} {}
+    EncodedAuthentication(std::string&& username, std::string&& password) : auth_string_{cpr::util::urlEncode(std::move(username)) + ":" + cpr::util::urlEncode(std::move(password))} {}
+    EncodedAuthentication(const EncodedAuthentication& other) = default;
+    EncodedAuthentication(EncodedAuthentication&& old) noexcept = default;
+    virtual ~EncodedAuthentication() noexcept;
+
+    EncodedAuthentication& operator=(EncodedAuthentication&& old) noexcept = default;
+    EncodedAuthentication& operator=(const EncodedAuthentication& other) = default;
+
+    const char* GetAuthString() const noexcept;
+
+  protected:
+    std::string auth_string_;
+};
+
+class ProxyAuthentication {
+  public:
+    ProxyAuthentication() = default;
+    ProxyAuthentication(const std::initializer_list<std::pair<const std::string, EncodedAuthentication>>& auths) : proxyAuth_{auths} {}
+    ProxyAuthentication(const std::map<std::string, EncodedAuthentication>& auths) : proxyAuth_{auths} {}
+
+    bool has(const std::string& protocol) const;
+    const char* operator[](const std::string& protocol);
+
+  private:
+    std::map<std::string, EncodedAuthentication> proxyAuth_;
+};
+
+} // namespace cpr
+
+#endif

EscapeTheBackroomsGUiTest/vcpkg_Out/include/cpr/range.h

@@ -0,0 +1,40 @@
+#ifndef CPR_RANGE_H
+#define CPR_RANGE_H
+
+#include <cstdint>
+
+namespace cpr {
+
+class Range {
+  public:
+    Range(const std::int64_t p_resume_from, const std::int64_t p_finish_at) : resume_from(p_resume_from), finish_at(p_finish_at) {}
+
+    std::int64_t resume_from = 0;
+    std::int64_t finish_at = 0;
+
+    const std::string str() const {
+        std::string from_str = (resume_from < (std::int64_t) 0) ? "" : std::to_string(resume_from);
+        std::string to_str = (finish_at < (std::int64_t) 0) ? "" : std::to_string(finish_at);
+        return from_str + "-" + to_str;
+    }
+};
+
+class MultiRange {
+  public:
+    MultiRange(std::initializer_list<Range> rs) : ranges{rs} {}
+
+    const std::string str() const {
+        std::string multi_range_string{};
+        for (Range range : ranges) {
+            multi_range_string += ((multi_range_string.empty()) ? "" : ", ") + range.str();
+        }
+        return multi_range_string;
+    }
+
+  private:
+    std::vector<Range> ranges;
+}; // namespace cpr
+
+} // namespace cpr
+
+#endif

EscapeTheBackroomsGUiTest/vcpkg_Out/include/cpr/redirect.h

@@ -0,0 +1,84 @@
+#ifndef CPR_REDIRECT_H
+#define CPR_REDIRECT_H
+
+#include <cstdint>
+
+namespace cpr {
+enum class PostRedirectFlags : uint8_t {
+    /**
+     * Respect RFC 7231 (section 6.4.2 to 6.4.4).
+     * Same as CURL_REDIR_POST_301 (https://curl.se/libcurl/c/CURLOPT_POSTREDIR.html).
+     **/
+    POST_301 = 0x1 << 0,
+    /**
+     * Maintain the request method after a 302 redirect.
+     * Same as CURL_REDIR_POST_302 (https://curl.se/libcurl/c/CURLOPT_POSTREDIR.html).
+     **/
+    POST_302 = 0x1 << 1,
+    /**
+     * Maintain the request method after a 303 redirect.
+     * Same as CURL_REDIR_POST_303 (https://curl.se/libcurl/c/CURLOPT_POSTREDIR.html).
+     **/
+    POST_303 = 0x1 << 2,
+    /**
+     * Default value.
+     * Convenience option to enable all flags.
+     * Same as CURL_REDIR_POST_ALL (https://curl.se/libcurl/c/CURLOPT_POSTREDIR.html).
+     **/
+    POST_ALL = POST_301 | POST_302 | POST_303,
+    /**
+     * * Convenience option to disable all flags.
+     **/
+    NONE = 0x0
+};
+
+PostRedirectFlags operator|(PostRedirectFlags lhs, PostRedirectFlags rhs);
+PostRedirectFlags operator&(PostRedirectFlags lhs, PostRedirectFlags rhs);
+PostRedirectFlags operator^(PostRedirectFlags lhs, PostRedirectFlags rhs);
+PostRedirectFlags operator~(PostRedirectFlags flag);
+PostRedirectFlags& operator|=(PostRedirectFlags& lhs, PostRedirectFlags rhs);
+PostRedirectFlags& operator&=(PostRedirectFlags& lhs, PostRedirectFlags rhs);
+PostRedirectFlags& operator^=(PostRedirectFlags& lhs, PostRedirectFlags rhs);
+bool any(PostRedirectFlags flag);
+
+class Redirect {
+  public:
+    /**
+     * The maximum number of redirects to follow.
+     * 0: Refuse any redirects.
+     * -1: Infinite number of redirects.
+     * Default: 50
+     * https://curl.se/libcurl/c/CURLOPT_MAXREDIRS.html
+     **/
+    // NOLINTNEXTLINE (google-runtime-int)
+    long maximum{50L};
+    /**
+     * Follow 3xx redirects.
+     * Default: true
+     * https://curl.se/libcurl/c/CURLOPT_FOLLOWLOCATION.html
+     **/
+    bool follow{true};
+    /**
+     * Continue to send authentication (user+password) credentials when following locations, even when hostname changed.
+     * Default: false
+     * https://curl.se/libcurl/c/CURLOPT_UNRESTRICTED_AUTH.html
+     **/
+    bool cont_send_cred{false};
+    /**
+     * Flags to control how to act after a redirect for a post request.
+     * Default: POST_ALL
+     **/
+    PostRedirectFlags post_flags{PostRedirectFlags::POST_ALL};
+
+    Redirect() = default;
+    // NOLINTNEXTLINE (google-runtime-int)
+    Redirect(long p_maximum, bool p_follow, bool p_cont_send_cred, PostRedirectFlags p_post_flags) : maximum(p_maximum), follow(p_follow), cont_send_cred(p_cont_send_cred), post_flags(p_post_flags){};
+    // NOLINTNEXTLINE (google-runtime-int)
+    explicit Redirect(long p_maximum) : maximum(p_maximum){};
+    explicit Redirect(bool p_follow) : follow(p_follow){};
+    Redirect(bool p_follow, bool p_cont_send_cred) : follow(p_follow), cont_send_cred(p_cont_send_cred){};
+    explicit Redirect(PostRedirectFlags p_post_flags) : post_flags(p_post_flags){};
+};
+} // namespace cpr
+
+#endif

EscapeTheBackroomsGUiTest/vcpkg_Out/include/cpr/reserve_size.h

@@ -0,0 +1,17 @@
+#ifndef CPR_RESERVE_SIZE_H
+#define CPR_RESERVE_SIZE_H
+
+#include <cstdint>
+
+namespace cpr {
+
+class ReserveSize {
+  public:
+    ReserveSize(const size_t _size) : size(_size) {}
+
+    size_t size = 0;
+};
+
+} // namespace cpr
+
+#endif

EscapeTheBackroomsGUiTest/vcpkg_Out/include/cpr/response.h

@@ -0,0 +1,55 @@
+#ifndef CPR_RESPONSE_H
+#define CPR_RESPONSE_H
+
+#include <cassert>
+#include <cstdint>
+#include <memory>
+#include <string>
+#include <utility>
+#include <vector>
+
+#include "cpr/cert_info.h"
+#include "cpr/cookies.h"
+#include "cpr/cprtypes.h"
+#include "cpr/error.h"
+#include "cpr/ssl_options.h"
+#include "cpr/util.h"
+
+namespace cpr {
+
+class Response {
+  private:
+    std::shared_ptr<CurlHolder> curl_{nullptr};
+
+  public:
+    // Ignored here since libcurl uses a long for this.
+    // NOLINTNEXTLINE(google-runtime-int)
+    long status_code{};
+    std::string text{};
+    Header header{};
+    Url url{};
+    double elapsed{};
+    Cookies cookies{};
+    Error error{};
+    std::string raw_header{};
+    std::string status_line{};
+    std::string reason{};
+    cpr_off_t uploaded_bytes{};
+    cpr_off_t downloaded_bytes{};
+    // Ignored here since libcurl uses a long for this.
+    // NOLINTNEXTLINE(google-runtime-int)
+    long redirect_count{};
+
+    Response() = default;
+    Response(std::shared_ptr<CurlHolder> curl, std::string&& p_text, std::string&& p_header_string, Cookies&& p_cookies, Error&& p_error);
+    std::vector<CertInfo> GetCertInfos();
+    Response(const Response& other) = default;
+    Response(Response&& old) noexcept = default;
+    ~Response() noexcept = default;
+
+    Response& operator=(Response&& old) noexcept = default;
+    Response& operator=(const Response& other) = default;
+};
+} // namespace cpr
+
+#endif

EscapeTheBackroomsGUiTest/vcpkg_Out/include/cpr/session.h

@@ -0,0 +1,290 @@
+#ifndef CPR_SESSION_H
+#define CPR_SESSION_H
+
+#include <cstdint>
+#include <fstream>
+#include <future>
+#include <memory>
+#include <queue>
+
+#include "cpr/accept_encoding.h"
+#include "cpr/auth.h"
+#include "cpr/bearer.h"
+#include "cpr/body.h"
+#include "cpr/callback.h"
+#include "cpr/connect_timeout.h"
+#include "cpr/cookies.h"
+#include "cpr/cprtypes.h"
+#include "cpr/curlholder.h"
+#include "cpr/http_version.h"
+#include "cpr/interface.h"
+#include "cpr/limit_rate.h"
+#include "cpr/local_port.h"
+#include "cpr/local_port_range.h"
+#include "cpr/low_speed.h"
+#include "cpr/multipart.h"
+#include "cpr/parameters.h"
+#include "cpr/payload.h"
+#include "cpr/proxies.h"
+#include "cpr/proxyauth.h"
+#include "cpr/range.h"
+#include "cpr/redirect.h"
+#include "cpr/reserve_size.h"
+#include "cpr/response.h"
+#include "cpr/ssl_options.h"
+#include "cpr/timeout.h"
+#include "cpr/unix_socket.h"
+#include "cpr/user_agent.h"
+#include "cpr/verbose.h"
+
+namespace cpr {
+
+using AsyncResponse = std::future<Response>;
+
+class Interceptor;
+
+class Session : public std::enable_shared_from_this<Session> {
+  public:
+    Session();
+    Session(const Session& other) = delete;
+
+    ~Session() = default;
+
+    Session& operator=(Session&& old) noexcept = default;
+    Session& operator=(const Session& other) = delete;
+
+    void SetUrl(const Url& url);
+    void SetParameters(const Parameters& parameters);
+    void SetParameters(Parameters&& parameters);
+    void SetHeader(const Header& header);
+    void UpdateHeader(const Header& header);
+    void SetTimeout(const Timeout& timeout);
+    void SetConnectTimeout(const ConnectTimeout& timeout);
+    void SetAuth(const Authentication& auth);
+// Only supported with libcurl >= 7.61.0.
+// As an alternative use SetHeader and add the token manually.
+#if LIBCURL_VERSION_NUM >= 0x073D00
+    void SetBearer(const Bearer& token);
+#endif
+    void SetUserAgent(const UserAgent& ua);
+    void SetPayload(Payload&& payload);
+    void SetPayload(const Payload& payload);
+    void SetProxies(Proxies&& proxies);
+    void SetProxies(const Proxies& proxies);
+    void SetProxyAuth(ProxyAuthentication&& proxy_auth);
+    void SetProxyAuth(const ProxyAuthentication& proxy_auth);
+    void SetMultipart(Multipart&& multipart);
+    void SetMultipart(const Multipart& multipart);
+    void SetRedirect(const Redirect& redirect);
+    void SetCookies(const Cookies& cookies);
+    void SetBody(Body&& body);
+    void SetBody(const Body& body);
+    void SetLowSpeed(const LowSpeed& low_speed);
+    void SetVerifySsl(const VerifySsl& verify);
+    void SetUnixSocket(const UnixSocket& unix_socket);
+    void SetSslOptions(const SslOptions& options);
+    void SetReadCallback(const ReadCallback& read);
+    void SetHeaderCallback(const HeaderCallback& header);
+    void SetWriteCallback(const WriteCallback& write);
+    void SetProgressCallback(const ProgressCallback& progress);
+    void SetDebugCallback(const DebugCallback& debug);
+    void SetVerbose(const Verbose& verbose);
+    void SetInterface(const Interface& iface);
+    void SetLocalPort(const LocalPort& local_port);
+    void SetLocalPortRange(const LocalPortRange& local_port_range);
+    void SetHttpVersion(const HttpVersion& version);
+    void SetRange(const Range& range);
+    void SetMultiRange(const MultiRange& multi_range);
+    void SetReserveSize(const ReserveSize& reserve_size);
+    void SetAcceptEncoding(const AcceptEncoding& accept_encoding);
+    void SetAcceptEncoding(AcceptEncoding&& accept_encoding);
+    void SetLimitRate(const LimitRate& limit_rate);
+
+    // Used in templated functions
+    void SetOption(const Url& url);
+    void SetOption(const Parameters& parameters);
+    void SetOption(Parameters&& parameters);
+    void SetOption(const Header& header);
+    void SetOption(const Timeout& timeout);
+    void SetOption(const ConnectTimeout& timeout);
+    void SetOption(const Authentication& auth);
+// Only supported with libcurl >= 7.61.0.
+// As an alternative use SetHeader and add the token manually.
+#if LIBCURL_VERSION_NUM >= 0x073D00
+    void SetOption(const Bearer& auth);
+#endif
+    void SetOption(const UserAgent& ua);
+    void SetOption(Payload&& payload);
+    void SetOption(const Payload& payload);
+    void SetOption(const LimitRate& limit_rate);
+    void SetOption(Proxies&& proxies);
+    void SetOption(const Proxies& proxies);
+    void SetOption(ProxyAuthentication&& proxy_auth);
+    void SetOption(const ProxyAuthentication& proxy_auth);
+    void SetOption(Multipart&& multipart);
+    void SetOption(const Multipart& multipart);
+    void SetOption(const Redirect& redirect);
+    void SetOption(const Cookies& cookies);
+    void SetOption(Body&& body);
+    void SetOption(const Body& body);
+    void SetOption(const ReadCallback& read);
+    void SetOption(const HeaderCallback& header);
+    void SetOption(const WriteCallback& write);
+    void SetOption(const ProgressCallback& progress);
+    void SetOption(const DebugCallback& debug);
+    void SetOption(const LowSpeed& low_speed);
+    void SetOption(const VerifySsl& verify);
+    void SetOption(const Verbose& verbose);
+    void SetOption(const UnixSocket& unix_socket);
+    void SetOption(const SslOptions& options);
+    void SetOption(const Interface& iface);
+    void SetOption(const LocalPort& local_port);
+    void SetOption(const LocalPortRange& local_port_range);
+    void SetOption(const HttpVersion& version);
+    void SetOption(const Range& range);
+    void SetOption(const MultiRange& multi_range);
+    void SetOption(const ReserveSize& reserve_size);
+    void SetOption(const AcceptEncoding& accept_encoding);
+    void SetOption(AcceptEncoding&& accept_encoding);
+
+    cpr_off_t GetDownloadFileLength();
+    /**
+     * Attempt to preallocate enough memory for specified number of characters in the response string.
+     * Pass 0 to disable this behavior and let the response string be allocated dynamically on demand.
+     *
+     * Example:
+     * cpr::Session session;
+     * session.SetUrl(cpr::Url{"http://xxx/file"});
+     * session.ResponseStringReserve(1024 * 512); // Reserve space for at least 1024 * 512 characters
+     * cpr::Response r = session.Get();
+     **/
+    void ResponseStringReserve(size_t size);
+    Response Delete();
+    Response Download(const WriteCallback& write);
+    Response Download(std::ofstream& file);
+    Response Get();
+    Response Head();
+    Response Options();
+    Response Patch();
+    Response Post();
+    Response Put();
+
+    AsyncResponse GetAsync();
+    AsyncResponse DeleteAsync();
+    AsyncResponse DownloadAsync(const WriteCallback& write);
+    AsyncResponse DownloadAsync(std::ofstream& file);
+    AsyncResponse HeadAsync();
+    AsyncResponse OptionsAsync();
+    AsyncResponse PatchAsync();
+    AsyncResponse PostAsync();
+    AsyncResponse PutAsync();
+
+    template <typename Then>
+    auto GetCallback(Then then) -> std::future<decltype(then(Get()))>;
+    template <typename Then>
+    auto PostCallback(Then then) -> std::future<decltype(then(Post()))>;
+    template <typename Then>
+    auto PutCallback(Then then) -> std::future<decltype(then(Put()))>;
+    template <typename Then>
+    auto HeadCallback(Then then) -> std::future<decltype(then(Head()))>;
+    template <typename Then>
+    auto DeleteCallback(Then then) -> std::future<decltype(then(Delete()))>;
+    template <typename Then>
+    auto OptionsCallback(Then then) -> std::future<decltype(then(Options()))>;
+    template <typename Then>
+    auto PatchCallback(Then then) -> std::future<decltype(then(Patch()))>;
+
+    std::shared_ptr<CurlHolder> GetCurlHolder();
+    std::string GetFullRequestUrl();
+
+    void PrepareDelete();
+    void PrepareGet();
+    void PrepareHead();
+    void PrepareOptions();
+    void PreparePatch();
+    void PreparePost();
+    void PreparePut();
+    Response Complete(CURLcode curl_error);
+
+    void AddInterceptor(const std::shared_ptr<Interceptor>& pinterceptor);
+
+  private:
+    // Interceptors should be able to call the private procceed() function
+    friend Interceptor;
+
+    bool hasBodyOrPayload_{false};
+    bool chunkedTransferEncoding_{false};
+    std::shared_ptr<CurlHolder> curl_;
+    Url url_;
+    Parameters parameters_;
+    Proxies proxies_;
+    ProxyAuthentication proxyAuth_;
+    Header header_;
+    AcceptEncoding acceptEncoding_;
+    /**
+     * Will be set by the read callback.
+     * Ensures that the "Transfer-Encoding" is set to "chunked", if not overriden in header_.
+     **/
+    ReadCallback readcb_;
+    HeaderCallback headercb_;
+    WriteCallback writecb_;
+    ProgressCallback progresscb_;
+    DebugCallback debugcb_;
+    size_t response_string_reserve_size_{0};
+    std::string response_string_;
+    std::string header_string_;
+    std::queue<std::shared_ptr<Interceptor>> interceptors_;
+
+    Response makeDownloadRequest();
+    Response makeRequest();
+    Response proceed();
+    void prepareCommon();
+    void SetHeaderInternal();
+    std::shared_ptr<Session> GetSharedPtrFromThis();
+};
+
+template <typename Then>
+auto Session::GetCallback(Then then) -> std::future<decltype(then(Get()))> {
+    auto shared_this = GetSharedPtrFromThis();
+    return async([shared_this](Then then_inner) { return then_inner(shared_this->Get()); }, std::move(then));
+}
+
+template <typename Then>
+auto Session::PostCallback(Then then) -> std::future<decltype(then(Post()))> {
+    auto shared_this = GetSharedPtrFromThis();
+    return async([shared_this](Then then_inner) { return then_inner(shared_this->Post()); }, std::move(then));
+}
+
+template <typename Then>
+auto Session::PutCallback(Then then) -> std::future<decltype(then(Put()))> {
+    auto shared_this = GetSharedPtrFromThis();
+    return async([shared_this](Then then_inner) { return then_inner(shared_this->Put()); }, std::move(then));
+}
+
+template <typename Then>
+auto Session::HeadCallback(Then then) -> std::future<decltype(then(Head()))> {
+    auto shared_this = GetSharedPtrFromThis();
+    return async([shared_this](Then then_inner) { return then_inner(shared_this->Head()); }, std::move(then));
+}
+
+template <typename Then>
+auto Session::DeleteCallback(Then then) -> std::future<decltype(then(Delete()))> {
+    auto shared_this = GetSharedPtrFromThis();
+    return async([shared_this](Then then_inner) { return then_inner(shared_this->Delete()); }, std::move(then));
+}
+
+template <typename Then>
+auto Session::OptionsCallback(Then then) -> std::future<decltype(then(Options()))> {
+    auto shared_this = GetSharedPtrFromThis();
+    return async([shared_this](Then then_inner) { return then_inner(shared_this->Options()); }, std::move(then));
+}
+
+template <typename Then>
+auto Session::PatchCallback(Then then) -> std::future<decltype(then(Patch()))> {
+    auto shared_this = GetSharedPtrFromThis();
+    return async([shared_this](Then then_inner) { return then_inner(shared_this->Patch()); }, std::move(then));
+}
+
+} // namespace cpr
+
+#endif

EscapeTheBackroomsGUiTest/vcpkg_Out/include/cpr/singleton.h

@@ -0,0 +1,47 @@
+#ifndef CPR_SINGLETON_H
+#define CPR_SINGLETON_H
+
+#include <mutex>
+
+#ifndef CPR_DISABLE_COPY
+#define CPR_DISABLE_COPY(Class) \
+    Class(const Class&) = delete; \
+    Class& operator=(const Class&) = delete;
+#endif
+
+#ifndef CPR_SINGLETON_DECL
+#define CPR_SINGLETON_DECL(Class) \
+    public: \
+        static Class* GetInstance(); \
+        static void ExitInstance(); \
+    private: \
+        CPR_DISABLE_COPY(Class) \
+        static Class* s_pInstance; \
+        static std::mutex s_mutex;
+#endif
+
+#ifndef CPR_SINGLETON_IMPL
+#define CPR_SINGLETON_IMPL(Class) \
+    Class* Class::s_pInstance = nullptr; \
+    std::mutex Class::s_mutex; \
+    Class* Class::GetInstance() { \
+        if (s_pInstance == nullptr) { \
+            s_mutex.lock(); \
+            if (s_pInstance == nullptr) { \
+                s_pInstance = new Class; \
+            } \
+            s_mutex.unlock(); \
+        } \
+        return s_pInstance; \
+    } \
+    void Class::ExitInstance() { \
+        s_mutex.lock(); \
+        if (s_pInstance) {  \
+            delete s_pInstance; \
+            s_pInstance = nullptr; \
+        }   \
+        s_mutex.unlock(); \
+    }
+#endif
+
+#endif

EscapeTheBackroomsGUiTest/vcpkg_Out/include/cpr/ssl_ctx.h

@@ -0,0 +1,26 @@
+#ifndef CPR_SSL_CTX_H
+#define CPR_SSL_CTX_H
+
+#include "cpr/ssl_options.h"
+#include <curl/curl.h>
+
+#if SUPPORT_CURLOPT_SSL_CTX_FUNCTION
+
+namespace cpr {
+
+/**
+ * This callback function loads a CA certificate from raw_cert_buf and gets called by libcurl
+ * just before the initialization of an SSL connection.
+ * The raw_cert_buf argument is set with the CURLOPT_SSL_CTX_DATA option and has to be a nul
+ * terminated buffer.
+ *
+ * Sources: https://curl.se/libcurl/c/CURLOPT_SSL_CTX_FUNCTION.html
+ *         https://curl.se/libcurl/c/CURLOPT_SSL_CTX_DATA.html
+ */
+CURLcode sslctx_function_load_ca_cert_from_buffer(CURL* curl, void* sslctx, void* raw_cert_buf);
+
+} // Namespace cpr
+
+#endif
+
+#endif

EscapeTheBackroomsGUiTest/vcpkg_Out/include/cpr/ssl_options.h

@@ -0,0 +1,616 @@
+#ifndef CPR_SSLOPTIONS_H
+#define CPR_SSLOPTIONS_H
+
+#include <memory>
+#include <string>
+#include <vector>
+
+#include <curl/curl.h>
+
+#include "cpr/util.h"
+#include <utility>
+
+#define __LIBCURL_VERSION_GTE(major, minor) ((LIBCURL_VERSION_MAJOR > (major)) || ((LIBCURL_VERSION_MAJOR == (major)) && (LIBCURL_VERSION_MINOR >= (minor))))
+#define __LIBCURL_VERSION_LT(major, minor) ((LIBCURL_VERSION_MAJOR < (major)) || ((LIBCURL_VERSION_MAJOR == (major)) && (LIBCURL_VERSION_MINOR < (minor))))
+
+#ifndef SUPPORT_ALPN
+#define SUPPORT_ALPN __LIBCURL_VERSION_GTE(7, 36)
+#endif
+#ifndef SUPPORT_NPN
+#define SUPPORT_NPN __LIBCURL_VERSION_GTE(7, 36)
+#endif
+
+#ifndef SUPPORT_SSLv2
+#define SUPPORT_SSLv2 __LIBCURL_VERSION_LT(7, 19)
+#endif
+#ifndef SUPPORT_SSLv3
+#define SUPPORT_SSLv3 __LIBCURL_VERSION_LT(7, 39)
+#endif
+#ifndef SUPPORT_TLSv1_0
+#define SUPPORT_TLSv1_0 __LIBCURL_VERSION_GTE(7, 34)
+#endif
+#ifndef SUPPORT_TLSv1_1
+#define SUPPORT_TLSv1_1 __LIBCURL_VERSION_GTE(7, 34)
+#endif
+#ifndef SUPPORT_TLSv1_2
+#define SUPPORT_TLSv1_2 __LIBCURL_VERSION_GTE(7, 34)
+#endif
+#ifndef SUPPORT_TLSv1_3
+#define SUPPORT_TLSv1_3 __LIBCURL_VERSION_GTE(7, 52)
+#endif
+#ifndef SUPPORT_MAX_TLS_VERSION
+#define SUPPORT_MAX_TLS_VERSION __LIBCURL_VERSION_GTE(7, 54)
+#endif
+#ifndef SUPPORT_MAX_TLSv1_1
+#define SUPPORT_MAX_TLSv1_1 __LIBCURL_VERSION_GTE(7, 54)
+#endif
+#ifndef SUPPORT_MAX_TLSv1_2
+#define SUPPORT_MAX_TLSv1_2 __LIBCURL_VERSION_GTE(7, 54)
+#endif
+#ifndef SUPPORT_MAX_TLSv1_3
+#define SUPPORT_MAX_TLSv1_3 __LIBCURL_VERSION_GTE(7, 54)
+#endif
+#ifndef SUPPORT_TLSv13_CIPHERS
+#define SUPPORT_TLSv13_CIPHERS __LIBCURL_VERSION_GTE(7, 61)
+#endif
+#ifndef SUPPORT_SESSIONID_CACHE
+#define SUPPORT_SESSIONID_CACHE __LIBCURL_VERSION_GTE(7, 16)
+#endif
+#ifndef SUPPORT_SSL_FALSESTART
+#define SUPPORT_SSL_FALSESTART __LIBCURL_VERSION_GTE(7, 42)
+#endif
+#ifndef SUPPORT_SSL_NO_REVOKE
+#define SUPPORT_SSL_NO_REVOKE __LIBCURL_VERSION_GTE(7, 44)
+#endif
+#ifndef SUPPORT_CURLOPT_SSLKEY_BLOB
+#define SUPPORT_CURLOPT_SSLKEY_BLOB __LIBCURL_VERSION_GTE(7, 71)
+#endif
+#ifndef SUPPORT_CURLOPT_SSL_CTX_FUNCTION
+#define SUPPORT_CURLOPT_SSL_CTX_FUNCTION __LIBCURL_VERSION_GTE(7, 11)
+#endif
+
+namespace cpr {
+
+class VerifySsl {
+  public:
+    VerifySsl() = default;
+    // NOLINTNEXTLINE(google-explicit-constructor, hicpp-explicit-conversions)
+    VerifySsl(bool p_verify) : verify(p_verify) {}
+
+    explicit operator bool() const {
+        return verify;
+    }
+
+    bool verify = true;
+};
+
+namespace ssl {
+
+// set SSL client certificate
+class CertFile {
+  public:
+    // NOLINTNEXTLINE(google-explicit-constructor, hicpp-explicit-conversions)
+    CertFile(std::string&& p_filename) : filename(std::move(p_filename)) {}
+
+    virtual ~CertFile() = default;
+
+    const std::string filename;
+
+    virtual const char* GetCertType() const {
+        return "PEM";
+    }
+};
+
+using PemCert = CertFile;
+
+class DerCert : public CertFile {
+  public:
+    // NOLINTNEXTLINE(google-explicit-constructor, hicpp-explicit-conversions)
+    DerCert(std::string&& p_filename) : CertFile(std::move(p_filename)) {}
+
+    virtual ~DerCert() = default;
+
+    const char* GetCertType() const override {
+        return "DER";
+    }
+};
+
+// specify private keyfile for TLS and SSL client cert
+class KeyFile {
+  public:
+    // NOLINTNEXTLINE(google-explicit-constructor, hicpp-explicit-conversions)
+    KeyFile(std::string&& p_filename) : filename(std::move(p_filename)) {}
+
+    template <typename FileType, typename PassType>
+    KeyFile(FileType&& p_filename, PassType p_password) : filename(std::forward<FileType>(p_filename)), password(std::move(p_password)) {}
+
+    virtual ~KeyFile() {
+        util::secureStringClear(password);
+    }
+
+    std::string filename;
+    std::string password;
+
+    virtual const char* GetKeyType() const {
+        return "PEM";
+    }
+};
+
+#if SUPPORT_CURLOPT_SSLKEY_BLOB
+class KeyBlob {
+  public:
+    // NOLINTNEXTLINE(google-explicit-constructor, hicpp-explicit-conversions)
+    KeyBlob(std::string&& p_blob) : blob(std::move(p_blob)) {}
+
+    template <typename BlobType, typename PassType>
+    KeyBlob(BlobType&& p_blob, PassType p_password) : blob(std::forward<BlobType>(p_blob)), password(std::move(p_password)) {}
+
+    virtual ~KeyBlob() {
+        util::secureStringClear(password);
+    }
+
+    std::string blob;
+    std::string password;
+
+    virtual const char* GetKeyType() const {
+        return "PEM";
+    }
+};
+#endif
+
+using PemKey = KeyFile;
+
+class DerKey : public KeyFile {
+  public:
+    // NOLINTNEXTLINE(google-explicit-constructor, hicpp-explicit-conversions)
+    DerKey(std::string&& p_filename) : KeyFile(std::move(p_filename)) {}
+
+    template <typename FileType, typename PassType>
+    DerKey(FileType&& p_filename, PassType p_password) : KeyFile(std::forward<FileType>(p_filename), std::move(p_password)) {}
+
+    virtual ~DerKey() = default;
+
+    const char* GetKeyType() const override {
+        return "DER";
+    }
+};
+
+class PinnedPublicKey {
+  public:
+    // NOLINTNEXTLINE(google-explicit-constructor, hicpp-explicit-conversions)
+    PinnedPublicKey(std::string&& p_pinned_public_key) : pinned_public_key(std::move(p_pinned_public_key)) {}
+
+    const std::string pinned_public_key;
+};
+
+#if SUPPORT_ALPN
+// This option enables/disables ALPN in the SSL handshake (if the SSL backend libcurl is built to
+// use supports it), which can be used to negotiate http2.
+class ALPN {
+  public:
+    ALPN() = default;
+    // NOLINTNEXTLINE(google-explicit-constructor, hicpp-explicit-conversions)
+    ALPN(bool p_enabled) : enabled(p_enabled) {}
+
+    explicit operator bool() const {
+        return enabled;
+    }
+
+    bool enabled = true;
+};
+#endif // SUPPORT_ALPN
+
+#if SUPPORT_NPN
+//  This option enables/disables NPN in the SSL handshake (if the SSL backend libcurl is built to
+//  use supports it), which can be used to negotiate http2.
+class NPN {
+  public:
+    NPN() = default;
+    // NOLINTNEXTLINE(google-explicit-constructor, hicpp-explicit-conversions)
+    NPN(bool p_enabled) : enabled(p_enabled) {}
+
+    explicit operator bool() const {
+        return enabled;
+    }
+
+    bool enabled = true;
+};
+#endif // SUPPORT_NPN
+
+// This option determines whether libcurl verifies that the server cert is for the server it is
+// known as.
+class VerifyHost {
+  public:
+    VerifyHost() = default;
+    // NOLINTNEXTLINE(google-explicit-constructor, hicpp-explicit-conversions)
+    VerifyHost(bool p_enabled) : enabled(p_enabled) {}
+
+    explicit operator bool() const {
+        return enabled;
+    }
+
+    bool enabled = true;
+};
+
+// This option determines whether libcurl verifies the authenticity of the peer's certificate.
+class VerifyPeer {
+  public:
+    VerifyPeer() = default;
+    // NOLINTNEXTLINE(google-explicit-constructor, hicpp-explicit-conversions)
+    VerifyPeer(bool p_enabled) : enabled(p_enabled) {}
+
+    explicit operator bool() const {
+        return enabled;
+    }
+
+    bool enabled = true;
+};
+
+// This option determines whether libcurl verifies the status of the server cert using the
+// "Certificate Status Request" TLS extension (aka. OCSP stapling).
+class VerifyStatus {
+  public:
+    // NOLINTNEXTLINE(google-explicit-constructor, hicpp-explicit-conversions)
+    VerifyStatus(bool p_enabled) : enabled(p_enabled) {}
+
+    explicit operator bool() const {
+        return enabled;
+    }
+
+    bool enabled = false;
+};
+
+// TLS v1.0 or later
+struct TLSv1 {};
+#if SUPPORT_SSLv2
+// SSL v2 (but not SSLv3)
+struct SSLv2 {};
+#endif
+#if SUPPORT_SSLv3
+// SSL v3 (but not SSLv2)
+struct SSLv3 {};
+#endif
+#if SUPPORT_TLSv1_0
+// TLS v1.0 or later (Added in 7.34.0)
+struct TLSv1_0 {};
+#endif
+#if SUPPORT_TLSv1_1
+// TLS v1.1 or later (Added in 7.34.0)
+struct TLSv1_1 {};
+#endif
+#if SUPPORT_TLSv1_2
+// TLS v1.2 or later (Added in 7.34.0)
+struct TLSv1_2 {};
+#endif
+#if SUPPORT_TLSv1_3
+// TLS v1.3 or later (Added in 7.52.0)
+struct TLSv1_3 {};
+#endif
+#if SUPPORT_MAX_TLS_VERSION
+// The flag defines the maximum supported TLS version by libcurl, or the default value from the SSL
+// library is used.
+struct MaxTLSVersion {};
+#endif
+#if SUPPORT_MAX_TLSv1_0
+// The flag defines maximum supported TLS version as TLSv1.0. (Added in 7.54.0)
+struct MaxTLSv1_0 {};
+#endif
+#if SUPPORT_MAX_TLSv1_1
+// The flag defines maximum supported TLS version as TLSv1.1. (Added in 7.54.0)
+struct MaxTLSv1_1 {};
+#endif
+#if SUPPORT_MAX_TLSv1_2
+// The flag defines maximum supported TLS version as TLSv1.2. (Added in 7.54.0)
+struct MaxTLSv1_2 {};
+#endif
+#if SUPPORT_MAX_TLSv1_3
+// The flag defines maximum supported TLS version as TLSv1.3. (Added in 7.54.0)
+struct MaxTLSv1_3 {};
+#endif
+
+// path to Certificate Authority (CA) bundle
+class CaInfo {
+  public:
+    // NOLINTNEXTLINE(google-explicit-constructor, hicpp-explicit-conversions)
+    CaInfo(std::string&& p_filename) : filename(std::move(p_filename)) {}
+
+    std::string filename;
+};
+
+// specify directory holding CA certificates
+class CaPath {
+  public:
+    // NOLINTNEXTLINE(google-explicit-constructor, hicpp-explicit-conversions)
+    CaPath(std::string&& p_filename) : filename(std::move(p_filename)) {}
+
+    std::string filename;
+};
+
+#if SUPPORT_CURLOPT_SSL_CTX_FUNCTION
+class CaBuffer {
+  public:
+    // NOLINTNEXTLINE(google-explicit-constructor, hicpp-explicit-conversions)
+    CaBuffer(std::string&& p_buffer) : buffer(std::move(p_buffer)) {}
+
+    const std::string buffer;
+};
+#endif
+
+// specify a Certificate Revocation List file
+class Crl {
+  public:
+    // NOLINTNEXTLINE(google-explicit-constructor, hicpp-explicit-conversions)
+    Crl(std::string&& p_filename) : filename(std::move(p_filename)) {}
+
+    std::string filename;
+};
+
+// specify ciphers to use for TLS
+class Ciphers {
+  public:
+    // NOLINTNEXTLINE(google-explicit-constructor, hicpp-explicit-conversions)
+    Ciphers(std::string&& p_ciphers) : ciphers(std::move(p_ciphers)) {}
+
+    std::string ciphers;
+};
+
+#if SUPPORT_TLSv13_CIPHERS
+// specify ciphers suites to use for TLS 1.3
+class TLS13_Ciphers {
+  public:
+    // NOLINTNEXTLINE(google-explicit-constructor, hicpp-explicit-conversions)
+    TLS13_Ciphers(std::string&& p_ciphers) : ciphers(std::move(p_ciphers)) {}
+
+    std::string ciphers;
+};
+#endif
+
+#if SUPPORT_SESSIONID_CACHE
+// enable/disable use of the SSL session-ID cache
+class SessionIdCache {
+  public:
+    SessionIdCache() = default;
+    // NOLINTNEXTLINE(google-explicit-constructor, hicpp-explicit-conversions)
+    SessionIdCache(bool p_enabled) : enabled(p_enabled) {}
+
+    explicit operator bool() const {
+        return enabled;
+    }
+
+    bool enabled = true;
+};
+#endif
+
+#if SUPPORT_SSL_FALSESTART
+class SslFastStart {
+  public:
+    SslFastStart() = default;
+    // NOLINTNEXTLINE(google-explicit-constructor, hicpp-explicit-conversions)
+    SslFastStart(bool p_enabled) : enabled(p_enabled) {}
+
+    explicit operator bool() const {
+        return enabled;
+    }
+
+    bool enabled = false;
+};
+#endif
+
+class NoRevoke {
+  public:
+    NoRevoke() = default;
+    // NOLINTNEXTLINE(google-explicit-constructor, hicpp-explicit-conversions)
+    NoRevoke(bool p_enabled) : enabled(p_enabled) {}
+
+    explicit operator bool() const {
+        return enabled;
+    }
+
+    bool enabled = false;
+};
+
+} // namespace ssl
+
+struct SslOptions {
+    std::string cert_file;
+    std::string cert_type;
+    std::string key_file;
+#if SUPPORT_CURLOPT_SSLKEY_BLOB
+    std::string key_blob;
+#endif
+    std::string key_type;
+    std::string key_pass;
+    std::string pinned_public_key;
+#if SUPPORT_ALPN
+    bool enable_alpn = true;
+#endif // SUPPORT_ALPN
+#if SUPPORT_NPN
+    bool enable_npn = true;
+#endif // SUPPORT_ALPN
+    bool verify_host = true;
+    bool verify_peer = true;
+    bool verify_status = false;
+    int ssl_version = CURL_SSLVERSION_DEFAULT;
+#if SUPPORT_SSL_NO_REVOKE
+    bool ssl_no_revoke = false;
+#endif
+#if SUPPORT_MAX_TLS_VERSION
+    int max_version = CURL_SSLVERSION_MAX_DEFAULT;
+#endif
+    std::string ca_info;
+    std::string ca_path;
+#if SUPPORT_CURLOPT_SSL_CTX_FUNCTION
+    std::string ca_buffer;
+#endif
+    std::string crl_file;
+    std::string ciphers;
+#if SUPPORT_TLSv13_CIPHERS
+    std::string tls13_ciphers;
+#endif
+#if SUPPORT_SESSIONID_CACHE
+    bool session_id_cache = true;
+#endif
+
+    ~SslOptions() noexcept {
+#if SUPPORT_CURLOPT_SSLKEY_BLOB
+        util::secureStringClear(key_blob);
+#endif
+        util::secureStringClear(key_pass);
+    }
+
+    void SetOption(const ssl::CertFile& opt) {
+        cert_file = opt.filename;
+        cert_type = opt.GetCertType();
+    }
+    void SetOption(const ssl::KeyFile& opt) {
+        key_file = opt.filename;
+        key_type = opt.GetKeyType();
+        key_pass = opt.password;
+    }
+#if SUPPORT_CURLOPT_SSLKEY_BLOB
+    void SetOption(const ssl::KeyBlob& opt) {
+        key_blob = opt.blob;
+        key_type = opt.GetKeyType();
+        key_pass = opt.password;
+    }
+#endif
+    void SetOption(const ssl::PinnedPublicKey& opt) {
+        pinned_public_key = opt.pinned_public_key;
+    }
+
+#if SUPPORT_ALPN
+    void SetOption(const ssl::ALPN& opt) {
+        enable_alpn = opt.enabled;
+    }
+#endif // SUPPORT_ALPN
+#if SUPPORT_NPN
+    void SetOption(const ssl::NPN& opt) {
+        enable_npn = opt.enabled;
+    }
+#endif // SUPPORT_NPN
+    void SetOption(const ssl::VerifyHost& opt) {
+        verify_host = opt.enabled;
+    }
+    void SetOption(const ssl::VerifyPeer& opt) {
+        verify_peer = opt.enabled;
+    }
+    void SetOption(const ssl::VerifyStatus& opt) {
+        verify_status = opt.enabled;
+    }
+    void SetOption(const ssl::TLSv1& /*opt*/) {
+        ssl_version = CURL_SSLVERSION_TLSv1;
+    }
+#if SUPPORT_SSL_NO_REVOKE
+    void SetOption(const ssl::NoRevoke& opt) {
+        ssl_no_revoke = opt.enabled;
+    }
+#endif
+#if SUPPORT_SSLv2
+    void SetOption(const ssl::SSLv2& /*opt*/) {
+        ssl_version = CURL_SSLVERSION_SSLv2;
+    }
+#endif
+#if SUPPORT_SSLv3
+    void SetOption(const ssl::SSLv3& /*opt*/) {
+        ssl_version = CURL_SSLVERSION_SSLv3;
+    }
+#endif
+#if SUPPORT_TLSv1_0
+    void SetOption(const ssl::TLSv1_0& /*opt*/) {
+        ssl_version = CURL_SSLVERSION_TLSv1_0;
+    }
+#endif
+#if SUPPORT_TLSv1_1
+    void SetOption(const ssl::TLSv1_1& /*opt*/) {
+        ssl_version = CURL_SSLVERSION_TLSv1_1;
+    }
+#endif
+#if SUPPORT_TLSv1_2
+    void SetOption(const ssl::TLSv1_2& /*opt*/) {
+        ssl_version = CURL_SSLVERSION_TLSv1_2;
+    }
+#endif
+#if SUPPORT_TLSv1_3
+    void SetOption(const ssl::TLSv1_3& /*opt*/) {
+        ssl_version = CURL_SSLVERSION_TLSv1_3;
+    }
+#endif
+#if SUPPORT_MAX_TLS_VERSION
+    void SetOption(const ssl::MaxTLSVersion& /*opt*/) {
+        max_version = CURL_SSLVERSION_DEFAULT;
+    }
+#endif
+#if SUPPORT_MAX_TLSv1_0
+    void SetOption(const ssl::MaxTLSv1_0& opt) {
+        max_version = CURL_SSLVERSION_MAX_TLSv1_0;
+    }
+#endif
+#if SUPPORT_MAX_TLSv1_1
+    void SetOption(const ssl::MaxTLSv1_1& /*opt*/) {
+        max_version = CURL_SSLVERSION_MAX_TLSv1_1;
+    }
+#endif
+#if SUPPORT_MAX_TLSv1_2
+    void SetOption(const ssl::MaxTLSv1_2& /*opt*/) {
+        max_version = CURL_SSLVERSION_MAX_TLSv1_2;
+    }
+#endif
+#if SUPPORT_MAX_TLSv1_3
+    void SetOption(const ssl::MaxTLSv1_3& /*opt*/) {
+        max_version = CURL_SSLVERSION_MAX_TLSv1_3;
+    }
+#endif
+    void SetOption(const ssl::CaInfo& opt) {
+        ca_info = opt.filename;
+    }
+    void SetOption(const ssl::CaPath& opt) {
+        ca_path = opt.filename;
+    }
+#if SUPPORT_CURLOPT_SSL_CTX_FUNCTION
+    void SetOption(const ssl::CaBuffer& opt) {
+        ca_buffer = opt.buffer;
+    }
+#endif
+    void SetOption(const ssl::Crl& opt) {
+        crl_file = opt.filename;
+    }
+    void SetOption(const ssl::Ciphers& opt) {
+        ciphers = opt.ciphers;
+    }
+#if SUPPORT_TLSv13_CIPHERS
+    void SetOption(const ssl::TLS13_Ciphers& opt) {
+        tls13_ciphers = opt.ciphers;
+    }
+#endif
+#if SUPPORT_SESSIONID_CACHE
+    void SetOption(const ssl::SessionIdCache& opt) {
+        session_id_cache = opt.enabled;
+    }
+#endif
+};
+
+namespace priv {
+
+template <typename T>
+void set_ssl_option(SslOptions& opts, T&& t) {
+    opts.SetOption(std::forward<T>(t));
+}
+
+template <typename T, typename... Ts>
+void set_ssl_option(SslOptions& opts, T&& t, Ts&&... ts) {
+    set_ssl_option(opts, std::forward<T>(t));
+    set_ssl_option(opts, std::move(ts)...);
+}
+
+} // namespace priv
+
+template <typename... Ts>
+SslOptions Ssl(Ts&&... ts) {
+    SslOptions opts;
+    priv::set_ssl_option(opts, std::move(ts)...);
+    return opts;
+}
+
+} // namespace cpr
+
+#endif

EscapeTheBackroomsGUiTest/vcpkg_Out/include/cpr/status_codes.h

@@ -0,0 +1,100 @@
+#ifndef _CPR_STATUS_CODES
+#define _CPR_STATUS_CODES
+#include <cstdint>
+namespace cpr {
+namespace status {
+// Information responses
+constexpr std::int32_t HTTP_CONTINUE = 100;
+constexpr std::int32_t HTTP_SWITCHING_PROTOCOL = 101;
+constexpr std::int32_t HTTP_PROCESSING = 102;
+constexpr std::int32_t HTTP_EARLY_HINTS = 103;
+// Successful responses
+constexpr std::int32_t HTTP_OK = 200;
+constexpr std::int32_t HTTP_CREATED = 201;
+constexpr std::int32_t HTTP_ACCEPTED = 202;
+constexpr std::int32_t HTTP_NON_AUTHORITATIVE_INFORMATION = 203;
+constexpr std::int32_t HTTP_NO_CONTENT = 204;
+constexpr std::int32_t HTTP_RESET_CONTENT = 205;
+constexpr std::int32_t HTTP_PARTIAL_CONTENT = 206;
+constexpr std::int32_t HTTP_MULTI_STATUS = 207;
+constexpr std::int32_t HTTP_ALREADY_REPORTED = 208;
+constexpr std::int32_t HTTP_IM_USED = 226;
+// Redirection messages
+constexpr std::int32_t HTTP_MULTIPLE_CHOICE = 300;
+constexpr std::int32_t HTTP_MOVED_PERMANENTLY = 301;
+constexpr std::int32_t HTTP_FOUND = 302;
+constexpr std::int32_t HTTP_SEE_OTHER = 303;
+constexpr std::int32_t HTTP_NOT_MODIFIED = 304;
+constexpr std::int32_t HTTP_USE_PROXY = 305;
+constexpr std::int32_t HTTP_UNUSED = 306;
+constexpr std::int32_t HTTP_TEMPORARY_REDIRECT = 307;
+constexpr std::int32_t HTTP_PERMANENT_REDIRECT = 308;
+// Client error responses
+constexpr std::int32_t HTTP_BAD_REQUEST = 400;
+constexpr std::int32_t HTTP_UNAUTHORIZED = 401;
+constexpr std::int32_t HTTP_PAYMENT_REQUIRED = 402;
+constexpr std::int32_t HTTP_FORBIDDEN = 403;
+constexpr std::int32_t HTTP_NOT_FOUND = 404;
+constexpr std::int32_t HTTP_METHOD_NOT_ALLOWED = 405;
+constexpr std::int32_t HTTP_NOT_ACCEPTABLE = 406;
+constexpr std::int32_t HTTP_PROXY_AUTHENTICATION_REQUIRED = 407;
+constexpr std::int32_t HTTP_REQUEST_TIMEOUT = 408;
+constexpr std::int32_t HTTP_CONFLICT = 409;
+constexpr std::int32_t HTTP_GONE = 410;
+constexpr std::int32_t HTTP_LENGTH_REQUIRED = 411;
+constexpr std::int32_t HTTP_PRECONDITION_FAILED = 412;
+constexpr std::int32_t HTTP_PAYLOAD_TOO_LARGE = 413;
+constexpr std::int32_t HTTP_URI_TOO_LONG = 414;
+constexpr std::int32_t HTTP_UNSUPPORTED_MEDIA_TYPE = 415;
+constexpr std::int32_t HTTP_REQUESTED_RANGE_NOT_SATISFIABLE = 416;
+constexpr std::int32_t HTTP_EXPECTATION_FAILED = 417;
+constexpr std::int32_t HTTP_IM_A_TEAPOT = 418;
+constexpr std::int32_t HTTP_MISDIRECTED_REQUEST = 421;
+constexpr std::int32_t HTTP_UNPROCESSABLE_ENTITY = 422;
+constexpr std::int32_t HTTP_LOCKED = 423;
+constexpr std::int32_t HTTP_FAILED_DEPENDENCY = 424;
+constexpr std::int32_t HTTP_TOO_EARLY = 425;
+constexpr std::int32_t HTTP_UPGRADE_REQUIRED = 426;
+constexpr std::int32_t HTTP_PRECONDITION_REQUIRED = 428;
+constexpr std::int32_t HTTP_TOO_MANY_REQUESTS = 429;
+constexpr std::int32_t HTTP_REQUEST_HEADER_FIELDS_TOO_LARGE = 431;
+constexpr std::int32_t HTTP_UNAVAILABLE_FOR_LEGAL_REASONS = 451;
+// Server response errors
+constexpr std::int32_t HTTP_INTERNAL_SERVER_ERROR = 500;
+constexpr std::int32_t HTTP_NOT_IMPLEMENTED = 501;
+constexpr std::int32_t HTTP_BAD_GATEWAY = 502;
+constexpr std::int32_t HTTP_SERVICE_UNAVAILABLE = 503;
+constexpr std::int32_t HTTP_GATEWAY_TIMEOUT = 504;
+constexpr std::int32_t HTTP_HTTP_VERSION_NOT_SUPPORTED = 505;
+constexpr std::int32_t HTTP_VARIANT_ALSO_NEGOTIATES = 506;
+constexpr std::int32_t HTTP_INSUFFICIENT_STORAGE = 507;
+constexpr std::int32_t HTTP_LOOP_DETECTED = 508;
+constexpr std::int32_t HTTP_NOT_EXTENDED = 510;
+constexpr std::int32_t HTTP_NETWORK_AUTHENTICATION_REQUIRED = 511;
+
+constexpr std::int32_t INFO_CODE_OFFSET = 100;
+constexpr std::int32_t SUCCESS_CODE_OFFSET = 200;
+constexpr std::int32_t REDIRECT_CODE_OFFSET = 300;
+constexpr std::int32_t CLIENT_ERROR_CODE_OFFSET = 400;
+constexpr std::int32_t SERVER_ERROR_CODE_OFFSET = 500;
+constexpr std::int32_t MISC_CODE_OFFSET = 600;
+
+constexpr bool is_informational(const std::int32_t code) {
+    return (code >= INFO_CODE_OFFSET && code < SUCCESS_CODE_OFFSET);
+}
+constexpr bool is_success(const std::int32_t code) {
+    return (code >= SUCCESS_CODE_OFFSET && code < REDIRECT_CODE_OFFSET);
+}
+constexpr bool is_redirect(const std::int32_t code) {
+    return (code >= REDIRECT_CODE_OFFSET && code < CLIENT_ERROR_CODE_OFFSET);
+}
+constexpr bool is_client_error(const std::int32_t code) {
+    return (code >= CLIENT_ERROR_CODE_OFFSET && code < SERVER_ERROR_CODE_OFFSET);
+}
+constexpr bool is_server_error(const std::int32_t code) {
+    return (code >= SERVER_ERROR_CODE_OFFSET && code < MISC_CODE_OFFSET);
+}
+
+} // namespace status
+} // namespace cpr
+#endif

EscapeTheBackroomsGUiTest/vcpkg_Out/include/cpr/threadpool.h

@@ -0,0 +1,122 @@
+#ifndef CPR_THREAD_POOL_H
+#define CPR_THREAD_POOL_H
+
+#include <atomic>
+#include <chrono>
+#include <condition_variable>
+#include <functional>
+#include <future>
+#include <list>
+#include <memory>
+#include <mutex>
+#include <queue>
+#include <thread>
+#include <utility>
+
+#define CPR_DEFAULT_THREAD_POOL_MAX_THREAD_NUM std::thread::hardware_concurrency()
+
+constexpr size_t CPR_DEFAULT_THREAD_POOL_MIN_THREAD_NUM = 1;
+constexpr std::chrono::milliseconds CPR_DEFAULT_THREAD_POOL_MAX_IDLE_TIME{60000};
+
+namespace cpr {
+
+class ThreadPool {
+  public:
+    using Task = std::function<void()>;
+
+    explicit ThreadPool(size_t min_threads = CPR_DEFAULT_THREAD_POOL_MIN_THREAD_NUM, size_t max_threads = CPR_DEFAULT_THREAD_POOL_MAX_THREAD_NUM, std::chrono::milliseconds max_idle_ms = CPR_DEFAULT_THREAD_POOL_MAX_IDLE_TIME);
+
+    virtual ~ThreadPool();
+
+    void SetMinThreadNum(size_t min_threads) {
+        min_thread_num = min_threads;
+    }
+    void SetMaxThreadNum(size_t max_threads) {
+        max_thread_num = max_threads;
+    }
+    void SetMaxIdleTime(std::chrono::milliseconds ms) {
+        max_idle_time = ms;
+    }
+    size_t GetCurrentThreadNum() {
+        return cur_thread_num;
+    }
+    size_t GetIdleThreadNum() {
+        return idle_thread_num;
+    }
+    bool IsStarted() {
+        return status != STOP;
+    }
+    bool IsStopped() {
+        return status == STOP;
+    }
+
+    int Start(size_t start_threads = 0);
+    int Stop();
+    int Pause();
+    int Resume();
+    int Wait();
+
+    /**
+     * Return a future, calling future.get() will wait task done and return RetType.
+     * Submit(fn, args...)
+     * Submit(std::bind(&Class::mem_fn, &obj))
+     * Submit(std::mem_fn(&Class::mem_fn, &obj))
+     **/
+    template <class Fn, class... Args>
+    auto Submit(Fn&& fn, Args&&... args) -> std::future<decltype(fn(args...))> {
+        if (status == STOP) {
+            Start();
+        }
+        if (idle_thread_num <= 0 && cur_thread_num < max_thread_num) {
+            CreateThread();
+        }
+        using RetType = decltype(fn(args...));
+        auto task = std::make_shared<std::packaged_task<RetType()> >(std::bind(std::forward<Fn>(fn), std::forward<Args>(args)...));
+        std::future<RetType> future = task->get_future();
+        {
+            std::lock_guard<std::mutex> locker(task_mutex);
+            tasks.emplace([task] { (*task)(); });
+        }
+
+        task_cond.notify_one();
+        return future;
+    }
+
+  private:
+    bool CreateThread();
+    void AddThread(std::thread* thread);
+    void DelThread(std::thread::id id);
+
+  public:
+    size_t min_thread_num;
+    size_t max_thread_num;
+    std::chrono::milliseconds max_idle_time;
+
+  private:
+    enum Status {
+        STOP,
+        RUNNING,
+        PAUSE,
+    };
+
+    struct ThreadData {
+        std::shared_ptr<std::thread> thread;
+        std::thread::id id;
+        Status status;
+        time_t start_time;
+        time_t stop_time;
+    };
+
+    std::atomic<Status> status;
+    std::atomic<size_t> cur_thread_num;
+    std::atomic<size_t> idle_thread_num;
+    std::list<ThreadData> threads;
+    std::mutex thread_mutex;
+    std::queue<Task> tasks;
+    std::mutex task_mutex;
+    std::condition_variable task_cond;
+};
+
+} // namespace cpr
+
+#endif

EscapeTheBackroomsGUiTest/vcpkg_Out/include/cpr/timeout.h

@@ -0,0 +1,25 @@
+#ifndef CPR_TIMEOUT_H
+#define CPR_TIMEOUT_H
+
+#include <chrono>
+#include <cstdint>
+
+namespace cpr {
+
+class Timeout {
+  public:
+    // NOLINTNEXTLINE(google-explicit-constructor, hicpp-explicit-conversions)
+    Timeout(const std::chrono::milliseconds& duration) : ms{duration} {}
+    // NOLINTNEXTLINE(google-explicit-constructor, hicpp-explicit-conversions)
+    Timeout(const std::int32_t& milliseconds) : Timeout{std::chrono::milliseconds(milliseconds)} {}
+
+    // No way around since curl uses a long here.
+    // NOLINTNEXTLINE(google-runtime-int)
+    long Milliseconds() const;
+
+    std::chrono::milliseconds ms;
+};
+
+} // namespace cpr
+
+#endif

EscapeTheBackroomsGUiTest/vcpkg_Out/include/cpr/unix_socket.h

@@ -0,0 +1,21 @@
+#ifndef CPR_UNIX_SOCKET_H
+#define CPR_UNIX_SOCKET_H
+
+#include <string>
+
+namespace cpr {
+
+class UnixSocket {
+  public:
+    // NOLINTNEXTLINE(google-explicit-constructor, hicpp-explicit-conversions)
+    UnixSocket(std::string&& unix_socket) : unix_socket_(std::move(unix_socket)) {}
+
+    const char* GetUnixSocketString() const noexcept;
+
+  private:
+    const std::string unix_socket_;
+};
+
+} // namespace cpr
+
+#endif

EscapeTheBackroomsGUiTest/vcpkg_Out/include/cpr/user_agent.h

@@ -0,0 +1,31 @@
+#ifndef CPR_USERAGENT_H
+#define CPR_USERAGENT_H
+
+#include <initializer_list>
+#include <string>
+
+#include "cpr/cprtypes.h"
+
+namespace cpr {
+class UserAgent : public StringHolder<UserAgent> {
+  public:
+    UserAgent() : StringHolder<UserAgent>() {}
+    // NOLINTNEXTLINE(google-explicit-constructor, hicpp-explicit-conversions)
+    UserAgent(const std::string& useragent) : StringHolder<UserAgent>(useragent) {}
+    // NOLINTNEXTLINE(google-explicit-constructor, hicpp-explicit-conversions)
+    UserAgent(std::string&& useragent) : StringHolder<UserAgent>(std::move(useragent)) {}
+    // NOLINTNEXTLINE(google-explicit-constructor, hicpp-explicit-conversions)
+    UserAgent(const char* useragent) : StringHolder<UserAgent>(useragent) {}
+    UserAgent(const char* str, size_t len) : StringHolder<UserAgent>(str, len) {}
+    UserAgent(const std::initializer_list<std::string> args) : StringHolder<UserAgent>(args) {}
+    UserAgent(const UserAgent& other) = default;
+    UserAgent(UserAgent&& old) noexcept = default;
+    ~UserAgent() override = default;
+
+    UserAgent& operator=(UserAgent&& old) noexcept = default;
+    UserAgent& operator=(const UserAgent& other) = default;
+};
+
+} // namespace cpr
+
+#endif

EscapeTheBackroomsGUiTest/vcpkg_Out/include/cpr/util.h

@@ -0,0 +1,45 @@
+#ifndef CPR_UTIL_H
+#define CPR_UTIL_H
+
+#include <fstream>
+#include <string>
+#include <vector>
+
+#include "cpr/callback.h"
+#include "cpr/cookies.h"
+#include "cpr/cprtypes.h"
+#include "cpr/curlholder.h"
+
+namespace cpr {
+namespace util {
+
+Header parseHeader(const std::string& headers, std::string* status_line = nullptr, std::string* reason = nullptr);
+Cookies parseCookies(curl_slist* raw_cookies);
+size_t readUserFunction(char* ptr, size_t size, size_t nitems, const ReadCallback* read);
+size_t headerUserFunction(char* ptr, size_t size, size_t nmemb, const HeaderCallback* header);
+size_t writeFunction(char* ptr, size_t size, size_t nmemb, std::string* data);
+size_t writeFileFunction(char* ptr, size_t size, size_t nmemb, std::ofstream* file);
+size_t writeUserFunction(char* ptr, size_t size, size_t nmemb, const WriteCallback* write);
+#if LIBCURL_VERSION_NUM < 0x072000
+int progressUserFunction(const ProgressCallback* progress, double dltotal, double dlnow, double ultotal, double ulnow);
+#else
+int progressUserFunction(const ProgressCallback* progress, curl_off_t dltotal, curl_off_t dlnow, curl_off_t ultotal, curl_off_t ulnow);
+#endif
+int debugUserFunction(CURL* handle, curl_infotype type, char* data, size_t size, const DebugCallback* debug);
+std::vector<std::string> split(const std::string& to_split, char delimiter);
+std::string urlEncode(const std::string& s);
+std::string urlDecode(const std::string& s);
+
+/**
+ * Override the content of the provided string to hide sensitive data. The
+ * string content after invocation is undefined. The string size is reset to zero.
+ * impl. based on:
+ * https://github.com/ojeda/secure_clear/blob/master/example-implementation/secure_clear.h
+ **/
+void secureStringClear(std::string& s);
+bool isTrue(const std::string& s);
+
+} // namespace util
+} // namespace cpr
+
+#endif

EscapeTheBackroomsGUiTest/vcpkg_Out/include/cpr/verbose.h

@@ -0,0 +1,18 @@
+#ifndef CPR_VERBOSE_H_
+#define CPR_VERBOSE_H_
+
+namespace cpr {
+
+class Verbose {
+  public:
+    Verbose() = default;
+    // NOLINTNEXTLINE(google-explicit-constructor, hicpp-explicit-conversions)
+    Verbose(const bool p_verbose) : verbose{p_verbose} {}
+
+    bool verbose = true;
+};
+
+} // namespace cpr
+
+
+#endif /* CPR_VERBOSE_H_ */

EscapeTheBackroomsGUiTest/vcpkg_Out/include/curl/curlver.h

@@ -0,0 +1,79 @@
+#ifndef CURLINC_CURLVER_H
+#define CURLINC_CURLVER_H
+/***************************************************************************
+ *                                  _   _ ____  _
+ *  Project                     ___| | | |  _ \| |
+ *                             / __| | | | |_) | |
+ *                            | (__| |_| |  _ <| |___
+ *                             \___|\___/|_| \_\_____|
+ *
+ * Copyright (C) 1998 - 2022, Daniel Stenberg, <daniel@haxx.se>, et al.
+ *
+ * This software is licensed as described in the file COPYING, which
+ * you should have received as part of this distribution. The terms
+ * are also available at https://curl.se/docs/copyright.html.
+ *
+ * You may opt to use, copy, modify, merge, publish, distribute and/or sell
+ * copies of the Software, and permit persons to whom the Software is
+ * furnished to do so, under the terms of the COPYING file.
+ *
+ * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
+ * KIND, either express or implied.
+ *
+ * SPDX-License-Identifier: curl
+ *
+ ***************************************************************************/
+
+/* This header file contains nothing but libcurl version info, generated by
+   a script at release-time. This was made its own header file in 7.11.2 */
+
+/* This is the global package copyright */
+#define LIBCURL_COPYRIGHT "1996 - 2022 Daniel Stenberg, <daniel@haxx.se>."
+
+/* This is the version number of the libcurl package from which this header
+   file origins: */
+#define LIBCURL_VERSION "7.86.0-DEV"
+
+/* The numeric version number is also available "in parts" by using these
+   defines: */
+#define LIBCURL_VERSION_MAJOR 7
+#define LIBCURL_VERSION_MINOR 86
+#define LIBCURL_VERSION_PATCH 0
+
+/* This is the numeric version of the libcurl version number, meant for easier
+   parsing and comparisons by programs. The LIBCURL_VERSION_NUM define will
+   always follow this syntax:
+
+         0xXXYYZZ
+
+   Where XX, YY and ZZ are the main version, release and patch numbers in
+   hexadecimal (using 8 bits each). All three numbers are always represented
+   using two digits.  1.2 would appear as "0x010200" while version 9.11.7
+   appears as "0x090b07".
+
+   This 6-digit (24 bits) hexadecimal number does not show pre-release number,
+   and it is always a greater number in a more recent release. It makes
+   comparisons with greater than and less than work.
+
+   Note: This define is the full hex number and _does not_ use the
+   CURL_VERSION_BITS() macro since curl's own configure script greps for it
+   and needs it to contain the full number.
+*/
+#define LIBCURL_VERSION_NUM 0x075600
+
+/*
+ * This is the date and time when the full source package was created. The
+ * timestamp is not stored in git, as the timestamp is properly set in the
+ * tarballs by the maketgz script.
+ *
+ * The format of the date follows this template:
+ *
+ * "2007-11-23"
+ */
+#define LIBCURL_TIMESTAMP "[unreleased]"
+
+#define CURL_VERSION_BITS(x,y,z) ((x)<<16|(y)<<8|(z))
+#define CURL_AT_LEAST_VERSION(x,y,z) \
+  (LIBCURL_VERSION_NUM >= CURL_VERSION_BITS(x, y, z))
+
+#endif /* CURLINC_CURLVER_H */

EscapeTheBackroomsGUiTest/vcpkg_Out/include/curl/easy.h

@@ -0,0 +1,125 @@
+#ifndef CURLINC_EASY_H
+#define CURLINC_EASY_H
+/***************************************************************************
+ *                                  _   _ ____  _
+ *  Project                     ___| | | |  _ \| |
+ *                             / __| | | | |_) | |
+ *                            | (__| |_| |  _ <| |___
+ *                             \___|\___/|_| \_\_____|
+ *
+ * Copyright (C) 1998 - 2022, Daniel Stenberg, <daniel@haxx.se>, et al.
+ *
+ * This software is licensed as described in the file COPYING, which
+ * you should have received as part of this distribution. The terms
+ * are also available at https://curl.se/docs/copyright.html.
+ *
+ * You may opt to use, copy, modify, merge, publish, distribute and/or sell
+ * copies of the Software, and permit persons to whom the Software is
+ * furnished to do so, under the terms of the COPYING file.
+ *
+ * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
+ * KIND, either express or implied.
+ *
+ * SPDX-License-Identifier: curl
+ *
+ ***************************************************************************/
+#ifdef  __cplusplus
+extern "C" {
+#endif
+
+/* Flag bits in the curl_blob struct: */
+#define CURL_BLOB_COPY   1 /* tell libcurl to copy the data */
+#define CURL_BLOB_NOCOPY 0 /* tell libcurl to NOT copy the data */
+
+struct curl_blob {
+  void *data;
+  size_t len;
+  unsigned int flags; /* bit 0 is defined, the rest are reserved and should be
+                         left zeroes */
+};
+
+CURL_EXTERN CURL *curl_easy_init(void);
+CURL_EXTERN CURLcode curl_easy_setopt(CURL *curl, CURLoption option, ...);
+CURL_EXTERN CURLcode curl_easy_perform(CURL *curl);
+CURL_EXTERN void curl_easy_cleanup(CURL *curl);
+
+/*
+ * NAME curl_easy_getinfo()
+ *
+ * DESCRIPTION
+ *
+ * Request internal information from the curl session with this function.  The
+ * third argument MUST be a pointer to a long, a pointer to a char * or a
+ * pointer to a double (as the documentation describes elsewhere).  The data
+ * pointed to will be filled in accordingly and can be relied upon only if the
+ * function returns CURLE_OK.  This function is intended to get used *AFTER* a
+ * performed transfer, all results from this function are undefined until the
+ * transfer is completed.
+ */
+CURL_EXTERN CURLcode curl_easy_getinfo(CURL *curl, CURLINFO info, ...);
+
+
+/*
+ * NAME curl_easy_duphandle()
+ *
+ * DESCRIPTION
+ *
+ * Creates a new curl session handle with the same options set for the handle
+ * passed in. Duplicating a handle could only be a matter of cloning data and
+ * options, internal state info and things like persistent connections cannot
+ * be transferred. It is useful in multithreaded applications when you can run
+ * curl_easy_duphandle() for each new thread to avoid a series of identical
+ * curl_easy_setopt() invokes in every thread.
+ */
+CURL_EXTERN CURL *curl_easy_duphandle(CURL *curl);
+
+/*
+ * NAME curl_easy_reset()
+ *
+ * DESCRIPTION
+ *
+ * Re-initializes a CURL handle to the default values. This puts back the
+ * handle to the same state as it was in when it was just created.
+ *
+ * It does keep: live connections, the Session ID cache, the DNS cache and the
+ * cookies.
+ */
+CURL_EXTERN void curl_easy_reset(CURL *curl);
+
+/*
+ * NAME curl_easy_recv()
+ *
+ * DESCRIPTION
+ *
+ * Receives data from the connected socket. Use after successful
+ * curl_easy_perform() with CURLOPT_CONNECT_ONLY option.
+ */
+CURL_EXTERN CURLcode curl_easy_recv(CURL *curl, void *buffer, size_t buflen,
+                                    size_t *n);
+
+/*
+ * NAME curl_easy_send()
+ *
+ * DESCRIPTION
+ *
+ * Sends data over the connected socket. Use after successful
+ * curl_easy_perform() with CURLOPT_CONNECT_ONLY option.
+ */
+CURL_EXTERN CURLcode curl_easy_send(CURL *curl, const void *buffer,
+                                    size_t buflen, size_t *n);
+
+
+/*
+ * NAME curl_easy_upkeep()
+ *
+ * DESCRIPTION
+ *
+ * Performs connection upkeep for the given session handle.
+ */
+CURL_EXTERN CURLcode curl_easy_upkeep(CURL *curl);
+
+#ifdef  __cplusplus
+}
+#endif
+
+#endif

EscapeTheBackroomsGUiTest/vcpkg_Out/include/curl/header.h

@@ -0,0 +1,74 @@
+#ifndef CURLINC_HEADER_H
+#define CURLINC_HEADER_H
+/***************************************************************************
+ *                                  _   _ ____  _
+ *  Project                     ___| | | |  _ \| |
+ *                             / __| | | | |_) | |
+ *                            | (__| |_| |  _ <| |___
+ *                             \___|\___/|_| \_\_____|
+ *
+ * Copyright (C) 2018 - 2022, Daniel Stenberg, <daniel@haxx.se>, et al.
+ *
+ * This software is licensed as described in the file COPYING, which
+ * you should have received as part of this distribution. The terms
+ * are also available at https://curl.se/docs/copyright.html.
+ *
+ * You may opt to use, copy, modify, merge, publish, distribute and/or sell
+ * copies of the Software, and permit persons to whom the Software is
+ * furnished to do so, under the terms of the COPYING file.
+ *
+ * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
+ * KIND, either express or implied.
+ *
+ * SPDX-License-Identifier: curl
+ *
+ ***************************************************************************/
+
+#ifdef  __cplusplus
+extern "C" {
+#endif
+
+struct curl_header {
+  char *name;    /* this might not use the same case */
+  char *value;
+  size_t amount; /* number of headers using this name  */
+  size_t index;  /* ... of this instance, 0 or higher */
+  unsigned int origin; /* see bits below */
+  void *anchor; /* handle privately used by libcurl */
+};
+
+/* 'origin' bits */
+#define CURLH_HEADER    (1<<0) /* plain server header */
+#define CURLH_TRAILER   (1<<1) /* trailers */
+#define CURLH_CONNECT   (1<<2) /* CONNECT headers */
+#define CURLH_1XX       (1<<3) /* 1xx headers */
+#define CURLH_PSEUDO    (1<<4) /* pseudo headers */
+
+typedef enum {
+  CURLHE_OK,
+  CURLHE_BADINDEX,      /* header exists but not with this index */
+  CURLHE_MISSING,       /* no such header exists */
+  CURLHE_NOHEADERS,     /* no headers at all exist (yet) */
+  CURLHE_NOREQUEST,     /* no request with this number was used */
+  CURLHE_OUT_OF_MEMORY, /* out of memory while processing */
+  CURLHE_BAD_ARGUMENT,  /* a function argument was not okay */
+  CURLHE_NOT_BUILT_IN   /* if API was disabled in the build */
+} CURLHcode;
+
+CURL_EXTERN CURLHcode curl_easy_header(CURL *easy,
+                                       const char *name,
+                                       size_t index,
+                                       unsigned int origin,
+                                       int request,
+                                       struct curl_header **hout);
+
+CURL_EXTERN struct curl_header *curl_easy_nextheader(CURL *easy,
+                                                     unsigned int origin,
+                                                     int request,
+                                                     struct curl_header *prev);
+
+#ifdef __cplusplus
+} /* end of extern "C" */
+#endif
+
+#endif /* CURLINC_HEADER_H */

EscapeTheBackroomsGUiTest/vcpkg_Out/include/curl/mprintf.h

@@ -0,0 +1,52 @@
+#ifndef CURLINC_MPRINTF_H
+#define CURLINC_MPRINTF_H
+/***************************************************************************
+ *                                  _   _ ____  _
+ *  Project                     ___| | | |  _ \| |
+ *                             / __| | | | |_) | |
+ *                            | (__| |_| |  _ <| |___
+ *                             \___|\___/|_| \_\_____|
+ *
+ * Copyright (C) 1998 - 2022, Daniel Stenberg, <daniel@haxx.se>, et al.
+ *
+ * This software is licensed as described in the file COPYING, which
+ * you should have received as part of this distribution. The terms
+ * are also available at https://curl.se/docs/copyright.html.
+ *
+ * You may opt to use, copy, modify, merge, publish, distribute and/or sell
+ * copies of the Software, and permit persons to whom the Software is
+ * furnished to do so, under the terms of the COPYING file.
+ *
+ * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
+ * KIND, either express or implied.
+ *
+ * SPDX-License-Identifier: curl
+ *
+ ***************************************************************************/
+
+#include <stdarg.h>
+#include <stdio.h> /* needed for FILE */
+#include "curl.h"  /* for CURL_EXTERN */
+
+#ifdef  __cplusplus
+extern "C" {
+#endif
+
+CURL_EXTERN int curl_mprintf(const char *format, ...);
+CURL_EXTERN int curl_mfprintf(FILE *fd, const char *format, ...);
+CURL_EXTERN int curl_msprintf(char *buffer, const char *format, ...);
+CURL_EXTERN int curl_msnprintf(char *buffer, size_t maxlength,
+                               const char *format, ...);
+CURL_EXTERN int curl_mvprintf(const char *format, va_list args);
+CURL_EXTERN int curl_mvfprintf(FILE *fd, const char *format, va_list args);
+CURL_EXTERN int curl_mvsprintf(char *buffer, const char *format, va_list args);
+CURL_EXTERN int curl_mvsnprintf(char *buffer, size_t maxlength,
+                                const char *format, va_list args);
+CURL_EXTERN char *curl_maprintf(const char *format, ...);
+CURL_EXTERN char *curl_mvaprintf(const char *format, va_list args);
+
+#ifdef  __cplusplus
+}
+#endif
+
+#endif /* CURLINC_MPRINTF_H */

EscapeTheBackroomsGUiTest/vcpkg_Out/include/curl/multi.h

@@ -0,0 +1,460 @@
+#ifndef CURLINC_MULTI_H
+#define CURLINC_MULTI_H
+/***************************************************************************
+ *                                  _   _ ____  _
+ *  Project                     ___| | | |  _ \| |
+ *                             / __| | | | |_) | |
+ *                            | (__| |_| |  _ <| |___
+ *                             \___|\___/|_| \_\_____|
+ *
+ * Copyright (C) 1998 - 2022, Daniel Stenberg, <daniel@haxx.se>, et al.
+ *
+ * This software is licensed as described in the file COPYING, which
+ * you should have received as part of this distribution. The terms
+ * are also available at https://curl.se/docs/copyright.html.
+ *
+ * You may opt to use, copy, modify, merge, publish, distribute and/or sell
+ * copies of the Software, and permit persons to whom the Software is
+ * furnished to do so, under the terms of the COPYING file.
+ *
+ * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
+ * KIND, either express or implied.
+ *
+ * SPDX-License-Identifier: curl
+ *
+ ***************************************************************************/
+/*
+  This is an "external" header file. Don't give away any internals here!
+
+  GOALS
+
+  o Enable a "pull" interface. The application that uses libcurl decides where
+    and when to ask libcurl to get/send data.
+
+  o Enable multiple simultaneous transfers in the same thread without making it
+    complicated for the application.
+
+  o Enable the application to select() on its own file descriptors and curl's
+    file descriptors simultaneous easily.
+
+*/
+
+/*
+ * This header file should not really need to include "curl.h" since curl.h
+ * itself includes this file and we expect user applications to do #include
+ * <curl/curl.h> without the need for especially including multi.h.
+ *
+ * For some reason we added this include here at one point, and rather than to
+ * break existing (wrongly written) libcurl applications, we leave it as-is
+ * but with this warning attached.
+ */
+#include "curl.h"
+
+#ifdef  __cplusplus
+extern "C" {
+#endif
+
+#if defined(BUILDING_LIBCURL) || defined(CURL_STRICTER)
+typedef struct Curl_multi CURLM;
+#else
+typedef void CURLM;
+#endif
+
+typedef enum {
+  CURLM_CALL_MULTI_PERFORM = -1, /* please call curl_multi_perform() or
+                                    curl_multi_socket*() soon */
+  CURLM_OK,
+  CURLM_BAD_HANDLE,      /* the passed-in handle is not a valid CURLM handle */
+  CURLM_BAD_EASY_HANDLE, /* an easy handle was not good/valid */
+  CURLM_OUT_OF_MEMORY,   /* if you ever get this, you're in deep sh*t */
+  CURLM_INTERNAL_ERROR,  /* this is a libcurl bug */
+  CURLM_BAD_SOCKET,      /* the passed in socket argument did not match */
+  CURLM_UNKNOWN_OPTION,  /* curl_multi_setopt() with unsupported option */
+  CURLM_ADDED_ALREADY,   /* an easy handle already added to a multi handle was
+                            attempted to get added - again */
+  CURLM_RECURSIVE_API_CALL, /* an api function was called from inside a
+                               callback */
+  CURLM_WAKEUP_FAILURE,  /* wakeup is unavailable or failed */
+  CURLM_BAD_FUNCTION_ARGUMENT, /* function called with a bad parameter */
+  CURLM_ABORTED_BY_CALLBACK,
+  CURLM_UNRECOVERABLE_POLL,
+  CURLM_LAST
+} CURLMcode;
+
+/* just to make code nicer when using curl_multi_socket() you can now check
+   for CURLM_CALL_MULTI_SOCKET too in the same style it works for
+   curl_multi_perform() and CURLM_CALL_MULTI_PERFORM */
+#define CURLM_CALL_MULTI_SOCKET CURLM_CALL_MULTI_PERFORM
+
+/* bitmask bits for CURLMOPT_PIPELINING */
+#define CURLPIPE_NOTHING   0L
+#define CURLPIPE_HTTP1     1L
+#define CURLPIPE_MULTIPLEX 2L
+
+typedef enum {
+  CURLMSG_NONE, /* first, not used */
+  CURLMSG_DONE, /* This easy handle has completed. 'result' contains
+                   the CURLcode of the transfer */
+  CURLMSG_LAST /* last, not used */
+} CURLMSG;
+
+struct CURLMsg {
+  CURLMSG msg;       /* what this message means */
+  CURL *easy_handle; /* the handle it concerns */
+  union {
+    void *whatever;    /* message-specific data */
+    CURLcode result;   /* return code for transfer */
+  } data;
+};
+typedef struct CURLMsg CURLMsg;
+
+/* Based on poll(2) structure and values.
+ * We don't use pollfd and POLL* constants explicitly
+ * to cover platforms without poll(). */
+#define CURL_WAIT_POLLIN    0x0001
+#define CURL_WAIT_POLLPRI   0x0002
+#define CURL_WAIT_POLLOUT   0x0004
+
+struct curl_waitfd {
+  curl_socket_t fd;
+  short events;
+  short revents; /* not supported yet */
+};
+
+/*
+ * Name:    curl_multi_init()
+ *
+ * Desc:    initialize multi-style curl usage
+ *
+ * Returns: a new CURLM handle to use in all 'curl_multi' functions.
+ */
+CURL_EXTERN CURLM *curl_multi_init(void);
+
+/*
+ * Name:    curl_multi_add_handle()
+ *
+ * Desc:    add a standard curl handle to the multi stack
+ *
+ * Returns: CURLMcode type, general multi error code.
+ */
+CURL_EXTERN CURLMcode curl_multi_add_handle(CURLM *multi_handle,
+                                            CURL *curl_handle);
+
+ /*
+  * Name:    curl_multi_remove_handle()
+  *
+  * Desc:    removes a curl handle from the multi stack again
+  *
+  * Returns: CURLMcode type, general multi error code.
+  */
+CURL_EXTERN CURLMcode curl_multi_remove_handle(CURLM *multi_handle,
+                                               CURL *curl_handle);
+
+ /*
+  * Name:    curl_multi_fdset()
+  *
+  * Desc:    Ask curl for its fd_set sets. The app can use these to select() or
+  *          poll() on. We want curl_multi_perform() called as soon as one of
+  *          them are ready.
+  *
+  * Returns: CURLMcode type, general multi error code.
+  */
+CURL_EXTERN CURLMcode curl_multi_fdset(CURLM *multi_handle,
+                                       fd_set *read_fd_set,
+                                       fd_set *write_fd_set,
+                                       fd_set *exc_fd_set,
+                                       int *max_fd);
+
+/*
+ * Name:     curl_multi_wait()
+ *
+ * Desc:     Poll on all fds within a CURLM set as well as any
+ *           additional fds passed to the function.
+ *
+ * Returns:  CURLMcode type, general multi error code.
+ */
+CURL_EXTERN CURLMcode curl_multi_wait(CURLM *multi_handle,
+                                      struct curl_waitfd extra_fds[],
+                                      unsigned int extra_nfds,
+                                      int timeout_ms,
+                                      int *ret);
+
+/*
+ * Name:     curl_multi_poll()
+ *
+ * Desc:     Poll on all fds within a CURLM set as well as any
+ *           additional fds passed to the function.
+ *
+ * Returns:  CURLMcode type, general multi error code.
+ */
+CURL_EXTERN CURLMcode curl_multi_poll(CURLM *multi_handle,
+                                      struct curl_waitfd extra_fds[],
+                                      unsigned int extra_nfds,
+                                      int timeout_ms,
+                                      int *ret);
+
+/*
+ * Name:     curl_multi_wakeup()
+ *
+ * Desc:     wakes up a sleeping curl_multi_poll call.
+ *
+ * Returns:  CURLMcode type, general multi error code.
+ */
+CURL_EXTERN CURLMcode curl_multi_wakeup(CURLM *multi_handle);
+
+ /*
+  * Name:    curl_multi_perform()
+  *
+  * Desc:    When the app thinks there's data available for curl it calls this
+  *          function to read/write whatever there is right now. This returns
+  *          as soon as the reads and writes are done. This function does not
+  *          require that there actually is data available for reading or that
+  *          data can be written, it can be called just in case. It returns
+  *          the number of handles that still transfer data in the second
+  *          argument's integer-pointer.
+  *
+  * Returns: CURLMcode type, general multi error code. *NOTE* that this only
+  *          returns errors etc regarding the whole multi stack. There might
+  *          still have occurred problems on individual transfers even when
+  *          this returns OK.
+  */
+CURL_EXTERN CURLMcode curl_multi_perform(CURLM *multi_handle,
+                                         int *running_handles);
+
+ /*
+  * Name:    curl_multi_cleanup()
+  *
+  * Desc:    Cleans up and removes a whole multi stack. It does not free or
+  *          touch any individual easy handles in any way. We need to define
+  *          in what state those handles will be if this function is called
+  *          in the middle of a transfer.
+  *
+  * Returns: CURLMcode type, general multi error code.
+  */
+CURL_EXTERN CURLMcode curl_multi_cleanup(CURLM *multi_handle);
+
+/*
+ * Name:    curl_multi_info_read()
+ *
+ * Desc:    Ask the multi handle if there's any messages/informationals from
+ *          the individual transfers. Messages include informationals such as
+ *          error code from the transfer or just the fact that a transfer is
+ *          completed. More details on these should be written down as well.
+ *
+ *          Repeated calls to this function will return a new struct each
+ *          time, until a special "end of msgs" struct is returned as a signal
+ *          that there is no more to get at this point.
+ *
+ *          The data the returned pointer points to will not survive calling
+ *          curl_multi_cleanup().
+ *
+ *          The 'CURLMsg' struct is meant to be very simple and only contain
+ *          very basic information. If more involved information is wanted,
+ *          we will provide the particular "transfer handle" in that struct
+ *          and that should/could/would be used in subsequent
+ *          curl_easy_getinfo() calls (or similar). The point being that we
+ *          must never expose complex structs to applications, as then we'll
+ *          undoubtably get backwards compatibility problems in the future.
+ *
+ * Returns: A pointer to a filled-in struct, or NULL if it failed or ran out
+ *          of structs. It also writes the number of messages left in the
+ *          queue (after this read) in the integer the second argument points
+ *          to.
+ */
+CURL_EXTERN CURLMsg *curl_multi_info_read(CURLM *multi_handle,
+                                          int *msgs_in_queue);
+
+/*
+ * Name:    curl_multi_strerror()
+ *
+ * Desc:    The curl_multi_strerror function may be used to turn a CURLMcode
+ *          value into the equivalent human readable error string.  This is
+ *          useful for printing meaningful error messages.
+ *
+ * Returns: A pointer to a null-terminated error message.
+ */
+CURL_EXTERN const char *curl_multi_strerror(CURLMcode);
+
+/*
+ * Name:    curl_multi_socket() and
+ *          curl_multi_socket_all()
+ *
+ * Desc:    An alternative version of curl_multi_perform() that allows the
+ *          application to pass in one of the file descriptors that have been
+ *          detected to have "action" on them and let libcurl perform.
+ *          See man page for details.
+ */
+#define CURL_POLL_NONE   0
+#define CURL_POLL_IN     1
+#define CURL_POLL_OUT    2
+#define CURL_POLL_INOUT  3
+#define CURL_POLL_REMOVE 4
+
+#define CURL_SOCKET_TIMEOUT CURL_SOCKET_BAD
+
+#define CURL_CSELECT_IN   0x01
+#define CURL_CSELECT_OUT  0x02
+#define CURL_CSELECT_ERR  0x04
+
+typedef int (*curl_socket_callback)(CURL *easy,      /* easy handle */
+                                    curl_socket_t s, /* socket */
+                                    int what,        /* see above */
+                                    void *userp,     /* private callback
+                                                        pointer */
+                                    void *socketp);  /* private socket
+                                                        pointer */
+/*
+ * Name:    curl_multi_timer_callback
+ *
+ * Desc:    Called by libcurl whenever the library detects a change in the
+ *          maximum number of milliseconds the app is allowed to wait before
+ *          curl_multi_socket() or curl_multi_perform() must be called
+ *          (to allow libcurl's timed events to take place).
+ *
+ * Returns: The callback should return zero.
+ */
+typedef int (*curl_multi_timer_callback)(CURLM *multi,    /* multi handle */
+                                         long timeout_ms, /* see above */
+                                         void *userp);    /* private callback
+                                                             pointer */
+
+CURL_EXTERN CURLMcode curl_multi_socket(CURLM *multi_handle, curl_socket_t s,
+                                        int *running_handles);
+
+CURL_EXTERN CURLMcode curl_multi_socket_action(CURLM *multi_handle,
+                                               curl_socket_t s,
+                                               int ev_bitmask,
+                                               int *running_handles);
+
+CURL_EXTERN CURLMcode curl_multi_socket_all(CURLM *multi_handle,
+                                            int *running_handles);
+
+#ifndef CURL_ALLOW_OLD_MULTI_SOCKET
+/* This macro below was added in 7.16.3 to push users who recompile to use
+   the new curl_multi_socket_action() instead of the old curl_multi_socket()
+*/
+#define curl_multi_socket(x,y,z) curl_multi_socket_action(x,y,0,z)
+#endif
+
+/*
+ * Name:    curl_multi_timeout()
+ *
+ * Desc:    Returns the maximum number of milliseconds the app is allowed to
+ *          wait before curl_multi_socket() or curl_multi_perform() must be
+ *          called (to allow libcurl's timed events to take place).
+ *
+ * Returns: CURLM error code.
+ */
+CURL_EXTERN CURLMcode curl_multi_timeout(CURLM *multi_handle,
+                                         long *milliseconds);
+
+typedef enum {
+  /* This is the socket callback function pointer */
+  CURLOPT(CURLMOPT_SOCKETFUNCTION, CURLOPTTYPE_FUNCTIONPOINT, 1),
+
+  /* This is the argument passed to the socket callback */
+  CURLOPT(CURLMOPT_SOCKETDATA, CURLOPTTYPE_OBJECTPOINT, 2),
+
+    /* set to 1 to enable pipelining for this multi handle */
+  CURLOPT(CURLMOPT_PIPELINING, CURLOPTTYPE_LONG, 3),
+
+   /* This is the timer callback function pointer */
+  CURLOPT(CURLMOPT_TIMERFUNCTION, CURLOPTTYPE_FUNCTIONPOINT, 4),
+
+  /* This is the argument passed to the timer callback */
+  CURLOPT(CURLMOPT_TIMERDATA, CURLOPTTYPE_OBJECTPOINT, 5),
+
+  /* maximum number of entries in the connection cache */
+  CURLOPT(CURLMOPT_MAXCONNECTS, CURLOPTTYPE_LONG, 6),
+
+  /* maximum number of (pipelining) connections to one host */
+  CURLOPT(CURLMOPT_MAX_HOST_CONNECTIONS, CURLOPTTYPE_LONG, 7),
+
+  /* maximum number of requests in a pipeline */
+  CURLOPT(CURLMOPT_MAX_PIPELINE_LENGTH, CURLOPTTYPE_LONG, 8),
+
+  /* a connection with a content-length longer than this
+     will not be considered for pipelining */
+  CURLOPT(CURLMOPT_CONTENT_LENGTH_PENALTY_SIZE, CURLOPTTYPE_OFF_T, 9),
+
+  /* a connection with a chunk length longer than this
+     will not be considered for pipelining */
+  CURLOPT(CURLMOPT_CHUNK_LENGTH_PENALTY_SIZE, CURLOPTTYPE_OFF_T, 10),
+
+  /* a list of site names(+port) that are blocked from pipelining */
+  CURLOPT(CURLMOPT_PIPELINING_SITE_BL, CURLOPTTYPE_OBJECTPOINT, 11),
+
+  /* a list of server types that are blocked from pipelining */
+  CURLOPT(CURLMOPT_PIPELINING_SERVER_BL, CURLOPTTYPE_OBJECTPOINT, 12),
+
+  /* maximum number of open connections in total */
+  CURLOPT(CURLMOPT_MAX_TOTAL_CONNECTIONS, CURLOPTTYPE_LONG, 13),
+
+   /* This is the server push callback function pointer */
+  CURLOPT(CURLMOPT_PUSHFUNCTION, CURLOPTTYPE_FUNCTIONPOINT, 14),
+
+  /* This is the argument passed to the server push callback */
+  CURLOPT(CURLMOPT_PUSHDATA, CURLOPTTYPE_OBJECTPOINT, 15),
+
+  /* maximum number of concurrent streams to support on a connection */
+  CURLOPT(CURLMOPT_MAX_CONCURRENT_STREAMS, CURLOPTTYPE_LONG, 16),
+
+  CURLMOPT_LASTENTRY /* the last unused */
+} CURLMoption;
+
+
+/*
+ * Name:    curl_multi_setopt()
+ *
+ * Desc:    Sets options for the multi handle.
+ *
+ * Returns: CURLM error code.
+ */
+CURL_EXTERN CURLMcode curl_multi_setopt(CURLM *multi_handle,
+                                        CURLMoption option, ...);
+
+
+/*
+ * Name:    curl_multi_assign()
+ *
+ * Desc:    This function sets an association in the multi handle between the
+ *          given socket and a private pointer of the application. This is
+ *          (only) useful for curl_multi_socket uses.
+ *
+ * Returns: CURLM error code.
+ */
+CURL_EXTERN CURLMcode curl_multi_assign(CURLM *multi_handle,
+                                        curl_socket_t sockfd, void *sockp);
+
+
+/*
+ * Name: curl_push_callback
+ *
+ * Desc: This callback gets called when a new stream is being pushed by the
+ *       server. It approves or denies the new stream. It can also decide
+ *       to completely fail the connection.
+ *
+ * Returns: CURL_PUSH_OK, CURL_PUSH_DENY or CURL_PUSH_ERROROUT
+ */
+#define CURL_PUSH_OK       0
+#define CURL_PUSH_DENY     1
+#define CURL_PUSH_ERROROUT 2 /* added in 7.72.0 */
+
+struct curl_pushheaders;  /* forward declaration only */
+
+CURL_EXTERN char *curl_pushheader_bynum(struct curl_pushheaders *h,
+                                        size_t num);
+CURL_EXTERN char *curl_pushheader_byname(struct curl_pushheaders *h,
+                                         const char *name);
+
+typedef int (*curl_push_callback)(CURL *parent,
+                                  CURL *easy,
+                                  size_t num_headers,
+                                  struct curl_pushheaders *headers,
+                                  void *userp);
+
+#ifdef __cplusplus
+} /* end of extern "C" */
+#endif
+
+#endif

EscapeTheBackroomsGUiTest/vcpkg_Out/include/curl/options.h

@@ -0,0 +1,70 @@
+#ifndef CURLINC_OPTIONS_H
+#define CURLINC_OPTIONS_H
+/***************************************************************************
+ *                                  _   _ ____  _
+ *  Project                     ___| | | |  _ \| |
+ *                             / __| | | | |_) | |
+ *                            | (__| |_| |  _ <| |___
+ *                             \___|\___/|_| \_\_____|
+ *
+ * Copyright (C) 2018 - 2022, Daniel Stenberg, <daniel@haxx.se>, et al.
+ *
+ * This software is licensed as described in the file COPYING, which
+ * you should have received as part of this distribution. The terms
+ * are also available at https://curl.se/docs/copyright.html.
+ *
+ * You may opt to use, copy, modify, merge, publish, distribute and/or sell
+ * copies of the Software, and permit persons to whom the Software is
+ * furnished to do so, under the terms of the COPYING file.
+ *
+ * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
+ * KIND, either express or implied.
+ *
+ * SPDX-License-Identifier: curl
+ *
+ ***************************************************************************/
+
+#ifdef  __cplusplus
+extern "C" {
+#endif
+
+typedef enum {
+  CURLOT_LONG,    /* long (a range of values) */
+  CURLOT_VALUES,  /*      (a defined set or bitmask) */
+  CURLOT_OFF_T,   /* curl_off_t (a range of values) */
+  CURLOT_OBJECT,  /* pointer (void *) */
+  CURLOT_STRING,  /*         (char * to null-terminated buffer) */
+  CURLOT_SLIST,   /*         (struct curl_slist *) */
+  CURLOT_CBPTR,   /*         (void * passed as-is to a callback) */
+  CURLOT_BLOB,    /* blob (struct curl_blob *) */
+  CURLOT_FUNCTION /* function pointer */
+} curl_easytype;
+
+/* Flag bits */
+
+/* "alias" means it is provided for old programs to remain functional,
+   we prefer another name */
+#define CURLOT_FLAG_ALIAS (1<<0)
+
+/* The CURLOPTTYPE_* id ranges can still be used to figure out what type/size
+   to use for curl_easy_setopt() for the given id */
+struct curl_easyoption {
+  const char *name;
+  CURLoption id;
+  curl_easytype type;
+  unsigned int flags;
+};
+
+CURL_EXTERN const struct curl_easyoption *
+curl_easy_option_by_name(const char *name);
+
+CURL_EXTERN const struct curl_easyoption *
+curl_easy_option_by_id(CURLoption id);
+
+CURL_EXTERN const struct curl_easyoption *
+curl_easy_option_next(const struct curl_easyoption *prev);
+
+#ifdef __cplusplus
+} /* end of extern "C" */
+#endif
+#endif /* CURLINC_OPTIONS_H */

EscapeTheBackroomsGUiTest/vcpkg_Out/include/curl/stdcheaders.h

@@ -0,0 +1,35 @@
+#ifndef CURLINC_STDCHEADERS_H
+#define CURLINC_STDCHEADERS_H
+/***************************************************************************
+ *                                  _   _ ____  _
+ *  Project                     ___| | | |  _ \| |
+ *                             / __| | | | |_) | |
+ *                            | (__| |_| |  _ <| |___
+ *                             \___|\___/|_| \_\_____|
+ *
+ * Copyright (C) 1998 - 2022, Daniel Stenberg, <daniel@haxx.se>, et al.
+ *
+ * This software is licensed as described in the file COPYING, which
+ * you should have received as part of this distribution. The terms
+ * are also available at https://curl.se/docs/copyright.html.
+ *
+ * You may opt to use, copy, modify, merge, publish, distribute and/or sell
+ * copies of the Software, and permit persons to whom the Software is
+ * furnished to do so, under the terms of the COPYING file.
+ *
+ * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
+ * KIND, either express or implied.
+ *
+ * SPDX-License-Identifier: curl
+ *
+ ***************************************************************************/
+
+#include <sys/types.h>
+
+size_t fread(void *, size_t, size_t, FILE *);
+size_t fwrite(const void *, size_t, size_t, FILE *);
+
+int strcasecmp(const char *, const char *);
+int strncasecmp(const char *, const char *, size_t);
+
+#endif /* CURLINC_STDCHEADERS_H */

EscapeTheBackroomsGUiTest/vcpkg_Out/include/curl/system.h

@@ -0,0 +1,490 @@
+#ifndef CURLINC_SYSTEM_H
+#define CURLINC_SYSTEM_H
+/***************************************************************************
+ *                                  _   _ ____  _
+ *  Project                     ___| | | |  _ \| |
+ *                             / __| | | | |_) | |
+ *                            | (__| |_| |  _ <| |___
+ *                             \___|\___/|_| \_\_____|
+ *
+ * Copyright (C) 1998 - 2022, Daniel Stenberg, <daniel@haxx.se>, et al.
+ *
+ * This software is licensed as described in the file COPYING, which
+ * you should have received as part of this distribution. The terms
+ * are also available at https://curl.se/docs/copyright.html.
+ *
+ * You may opt to use, copy, modify, merge, publish, distribute and/or sell
+ * copies of the Software, and permit persons to whom the Software is
+ * furnished to do so, under the terms of the COPYING file.
+ *
+ * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
+ * KIND, either express or implied.
+ *
+ * SPDX-License-Identifier: curl
+ *
+ ***************************************************************************/
+
+/*
+ * Try to keep one section per platform, compiler and architecture, otherwise,
+ * if an existing section is reused for a different one and later on the
+ * original is adjusted, probably the piggybacking one can be adversely
+ * changed.
+ *
+ * In order to differentiate between platforms/compilers/architectures use
+ * only compiler built in predefined preprocessor symbols.
+ *
+ * curl_off_t
+ * ----------
+ *
+ * For any given platform/compiler curl_off_t must be typedef'ed to a 64-bit
+ * wide signed integral data type. The width of this data type must remain
+ * constant and independent of any possible large file support settings.
+ *
+ * As an exception to the above, curl_off_t shall be typedef'ed to a 32-bit
+ * wide signed integral data type if there is no 64-bit type.
+ *
+ * As a general rule, curl_off_t shall not be mapped to off_t. This rule shall
+ * only be violated if off_t is the only 64-bit data type available and the
+ * size of off_t is independent of large file support settings. Keep your
+ * build on the safe side avoiding an off_t gating.  If you have a 64-bit
+ * off_t then take for sure that another 64-bit data type exists, dig deeper
+ * and you will find it.
+ *
+ */
+
+#if defined(__DJGPP__) || defined(__GO32__)
+#  if defined(__DJGPP__) && (__DJGPP__ > 1)
+#    define CURL_TYPEOF_CURL_OFF_T     long long
+#    define CURL_FORMAT_CURL_OFF_T     "lld"
+#    define CURL_FORMAT_CURL_OFF_TU    "llu"
+#    define CURL_SUFFIX_CURL_OFF_T     LL
+#    define CURL_SUFFIX_CURL_OFF_TU    ULL
+#  else
+#    define CURL_TYPEOF_CURL_OFF_T     long
+#    define CURL_FORMAT_CURL_OFF_T     "ld"
+#    define CURL_FORMAT_CURL_OFF_TU    "lu"
+#    define CURL_SUFFIX_CURL_OFF_T     L
+#    define CURL_SUFFIX_CURL_OFF_TU    UL
+#  endif
+#  define CURL_TYPEOF_CURL_SOCKLEN_T int
+
+#elif defined(__SALFORDC__)
+#  define CURL_TYPEOF_CURL_OFF_T     long
+#  define CURL_FORMAT_CURL_OFF_T     "ld"
+#  define CURL_FORMAT_CURL_OFF_TU    "lu"
+#  define CURL_SUFFIX_CURL_OFF_T     L
+#  define CURL_SUFFIX_CURL_OFF_TU    UL
+#  define CURL_TYPEOF_CURL_SOCKLEN_T int
+
+#elif defined(__BORLANDC__)
+#  if (__BORLANDC__ < 0x520)
+#    define CURL_TYPEOF_CURL_OFF_T     long
+#    define CURL_FORMAT_CURL_OFF_T     "ld"
+#    define CURL_FORMAT_CURL_OFF_TU    "lu"
+#    define CURL_SUFFIX_CURL_OFF_T     L
+#    define CURL_SUFFIX_CURL_OFF_TU    UL
+#  else
+#    define CURL_TYPEOF_CURL_OFF_T     __int64
+#    define CURL_FORMAT_CURL_OFF_T     "I64d"
+#    define CURL_FORMAT_CURL_OFF_TU    "I64u"
+#    define CURL_SUFFIX_CURL_OFF_T     i64
+#    define CURL_SUFFIX_CURL_OFF_TU    ui64
+#  endif
+#  define CURL_TYPEOF_CURL_SOCKLEN_T int
+
+#elif defined(__TURBOC__)
+#  define CURL_TYPEOF_CURL_OFF_T     long
+#  define CURL_FORMAT_CURL_OFF_T     "ld"
+#  define CURL_FORMAT_CURL_OFF_TU    "lu"
+#  define CURL_SUFFIX_CURL_OFF_T     L
+#  define CURL_SUFFIX_CURL_OFF_TU    UL
+#  define CURL_TYPEOF_CURL_SOCKLEN_T int
+
+#elif defined(__POCC__)
+#  if (__POCC__ < 280)
+#    define CURL_TYPEOF_CURL_OFF_T     long
+#    define CURL_FORMAT_CURL_OFF_T     "ld"
+#    define CURL_FORMAT_CURL_OFF_TU    "lu"
+#    define CURL_SUFFIX_CURL_OFF_T     L
+#    define CURL_SUFFIX_CURL_OFF_TU    UL
+#  elif defined(_MSC_VER)
+#    define CURL_TYPEOF_CURL_OFF_T     __int64
+#    define CURL_FORMAT_CURL_OFF_T     "I64d"
+#    define CURL_FORMAT_CURL_OFF_TU    "I64u"
+#    define CURL_SUFFIX_CURL_OFF_T     i64
+#    define CURL_SUFFIX_CURL_OFF_TU    ui64
+#  else
+#    define CURL_TYPEOF_CURL_OFF_T     long long
+#    define CURL_FORMAT_CURL_OFF_T     "lld"
+#    define CURL_FORMAT_CURL_OFF_TU    "llu"
+#    define CURL_SUFFIX_CURL_OFF_T     LL
+#    define CURL_SUFFIX_CURL_OFF_TU    ULL
+#  endif
+#  define CURL_TYPEOF_CURL_SOCKLEN_T int
+
+#elif defined(__LCC__)
+#  if defined(__MCST__) /* MCST eLbrus Compiler Collection */
+#    define CURL_TYPEOF_CURL_OFF_T     long
+#    define CURL_FORMAT_CURL_OFF_T     "ld"
+#    define CURL_FORMAT_CURL_OFF_TU    "lu"
+#    define CURL_SUFFIX_CURL_OFF_T     L
+#    define CURL_SUFFIX_CURL_OFF_TU    UL
+#    define CURL_TYPEOF_CURL_SOCKLEN_T socklen_t
+#    define CURL_PULL_SYS_TYPES_H      1
+#    define CURL_PULL_SYS_SOCKET_H     1
+#  else                /* Local (or Little) C Compiler */
+#    define CURL_TYPEOF_CURL_OFF_T     long
+#    define CURL_FORMAT_CURL_OFF_T     "ld"
+#    define CURL_FORMAT_CURL_OFF_TU    "lu"
+#    define CURL_SUFFIX_CURL_OFF_T     L
+#    define CURL_SUFFIX_CURL_OFF_TU    UL
+#    define CURL_TYPEOF_CURL_SOCKLEN_T int
+#  endif
+
+#elif defined(__SYMBIAN32__)
+#  if defined(__EABI__) /* Treat all ARM compilers equally */
+#    define CURL_TYPEOF_CURL_OFF_T     long long
+#    define CURL_FORMAT_CURL_OFF_T     "lld"
+#    define CURL_FORMAT_CURL_OFF_TU    "llu"
+#    define CURL_SUFFIX_CURL_OFF_T     LL
+#    define CURL_SUFFIX_CURL_OFF_TU    ULL
+#  elif defined(__CW32__)
+#    pragma longlong on
+#    define CURL_TYPEOF_CURL_OFF_T     long long
+#    define CURL_FORMAT_CURL_OFF_T     "lld"
+#    define CURL_FORMAT_CURL_OFF_TU    "llu"
+#    define CURL_SUFFIX_CURL_OFF_T     LL
+#    define CURL_SUFFIX_CURL_OFF_TU    ULL
+#  elif defined(__VC32__)
+#    define CURL_TYPEOF_CURL_OFF_T     __int64
+#    define CURL_FORMAT_CURL_OFF_T     "lld"
+#    define CURL_FORMAT_CURL_OFF_TU    "llu"
+#    define CURL_SUFFIX_CURL_OFF_T     LL
+#    define CURL_SUFFIX_CURL_OFF_TU    ULL
+#  endif
+#  define CURL_TYPEOF_CURL_SOCKLEN_T unsigned int
+
+#elif defined(__MWERKS__)
+#  define CURL_TYPEOF_CURL_OFF_T     long long
+#  define CURL_FORMAT_CURL_OFF_T     "lld"
+#  define CURL_FORMAT_CURL_OFF_TU    "llu"
+#  define CURL_SUFFIX_CURL_OFF_T     LL
+#  define CURL_SUFFIX_CURL_OFF_TU    ULL
+#  define CURL_TYPEOF_CURL_SOCKLEN_T int
+
+#elif defined(_WIN32_WCE)
+#  define CURL_TYPEOF_CURL_OFF_T     __int64
+#  define CURL_FORMAT_CURL_OFF_T     "I64d"
+#  define CURL_FORMAT_CURL_OFF_TU    "I64u"
+#  define CURL_SUFFIX_CURL_OFF_T     i64
+#  define CURL_SUFFIX_CURL_OFF_TU    ui64
+#  define CURL_TYPEOF_CURL_SOCKLEN_T int
+
+#elif defined(__MINGW32__)
+#  define CURL_TYPEOF_CURL_OFF_T     long long
+#  define CURL_FORMAT_CURL_OFF_T     "I64d"
+#  define CURL_FORMAT_CURL_OFF_TU    "I64u"
+#  define CURL_SUFFIX_CURL_OFF_T     LL
+#  define CURL_SUFFIX_CURL_OFF_TU    ULL
+#  define CURL_TYPEOF_CURL_SOCKLEN_T socklen_t
+#  define CURL_PULL_SYS_TYPES_H      1
+#  define CURL_PULL_WS2TCPIP_H       1
+
+#elif defined(__VMS)
+#  if defined(__VAX)
+#    define CURL_TYPEOF_CURL_OFF_T     long
+#    define CURL_FORMAT_CURL_OFF_T     "ld"
+#    define CURL_FORMAT_CURL_OFF_TU    "lu"
+#    define CURL_SUFFIX_CURL_OFF_T     L
+#    define CURL_SUFFIX_CURL_OFF_TU    UL
+#  else
+#    define CURL_TYPEOF_CURL_OFF_T     long long
+#    define CURL_FORMAT_CURL_OFF_T     "lld"
+#    define CURL_FORMAT_CURL_OFF_TU    "llu"
+#    define CURL_SUFFIX_CURL_OFF_T     LL
+#    define CURL_SUFFIX_CURL_OFF_TU    ULL
+#  endif
+#  define CURL_TYPEOF_CURL_SOCKLEN_T unsigned int
+
+#elif defined(__OS400__)
+#  if defined(__ILEC400__)
+#    define CURL_TYPEOF_CURL_OFF_T     long long
+#    define CURL_FORMAT_CURL_OFF_T     "lld"
+#    define CURL_FORMAT_CURL_OFF_TU    "llu"
+#    define CURL_SUFFIX_CURL_OFF_T     LL
+#    define CURL_SUFFIX_CURL_OFF_TU    ULL
+#    define CURL_TYPEOF_CURL_SOCKLEN_T socklen_t
+#    define CURL_PULL_SYS_TYPES_H      1
+#    define CURL_PULL_SYS_SOCKET_H     1
+#  endif
+
+#elif defined(__MVS__)
+#  if defined(__IBMC__) || defined(__IBMCPP__)
+#    if defined(_ILP32)
+#    elif defined(_LP64)
+#    endif
+#    if defined(_LONG_LONG)
+#      define CURL_TYPEOF_CURL_OFF_T     long long
+#      define CURL_FORMAT_CURL_OFF_T     "lld"
+#      define CURL_FORMAT_CURL_OFF_TU    "llu"
+#      define CURL_SUFFIX_CURL_OFF_T     LL
+#      define CURL_SUFFIX_CURL_OFF_TU    ULL
+#    elif defined(_LP64)
+#      define CURL_TYPEOF_CURL_OFF_T     long
+#      define CURL_FORMAT_CURL_OFF_T     "ld"
+#      define CURL_FORMAT_CURL_OFF_TU    "lu"
+#      define CURL_SUFFIX_CURL_OFF_T     L
+#      define CURL_SUFFIX_CURL_OFF_TU    UL
+#    else
+#      define CURL_TYPEOF_CURL_OFF_T     long
+#      define CURL_FORMAT_CURL_OFF_T     "ld"
+#      define CURL_FORMAT_CURL_OFF_TU    "lu"
+#      define CURL_SUFFIX_CURL_OFF_T     L
+#      define CURL_SUFFIX_CURL_OFF_TU    UL
+#    endif
+#    define CURL_TYPEOF_CURL_SOCKLEN_T socklen_t
+#    define CURL_PULL_SYS_TYPES_H      1
+#    define CURL_PULL_SYS_SOCKET_H     1
+#  endif
+
+#elif defined(__370__)
+#  if defined(__IBMC__) || defined(__IBMCPP__)
+#    if defined(_ILP32)
+#    elif defined(_LP64)
+#    endif
+#    if defined(_LONG_LONG)
+#      define CURL_TYPEOF_CURL_OFF_T     long long
+#      define CURL_FORMAT_CURL_OFF_T     "lld"
+#      define CURL_FORMAT_CURL_OFF_TU    "llu"
+#      define CURL_SUFFIX_CURL_OFF_T     LL
+#      define CURL_SUFFIX_CURL_OFF_TU    ULL
+#    elif defined(_LP64)
+#      define CURL_TYPEOF_CURL_OFF_T     long
+#      define CURL_FORMAT_CURL_OFF_T     "ld"
+#      define CURL_FORMAT_CURL_OFF_TU    "lu"
+#      define CURL_SUFFIX_CURL_OFF_T     L
+#      define CURL_SUFFIX_CURL_OFF_TU    UL
+#    else
+#      define CURL_TYPEOF_CURL_OFF_T     long
+#      define CURL_FORMAT_CURL_OFF_T     "ld"
+#      define CURL_FORMAT_CURL_OFF_TU    "lu"
+#      define CURL_SUFFIX_CURL_OFF_T     L
+#      define CURL_SUFFIX_CURL_OFF_TU    UL
+#    endif
+#    define CURL_TYPEOF_CURL_SOCKLEN_T socklen_t
+#    define CURL_PULL_SYS_TYPES_H      1
+#    define CURL_PULL_SYS_SOCKET_H     1
+#  endif
+
+#elif defined(TPF)
+#  define CURL_TYPEOF_CURL_OFF_T     long
+#  define CURL_FORMAT_CURL_OFF_T     "ld"
+#  define CURL_FORMAT_CURL_OFF_TU    "lu"
+#  define CURL_SUFFIX_CURL_OFF_T     L
+#  define CURL_SUFFIX_CURL_OFF_TU    UL
+#  define CURL_TYPEOF_CURL_SOCKLEN_T int
+
+#elif defined(__TINYC__) /* also known as tcc */
+#  define CURL_TYPEOF_CURL_OFF_T     long long
+#  define CURL_FORMAT_CURL_OFF_T     "lld"
+#  define CURL_FORMAT_CURL_OFF_TU    "llu"
+#  define CURL_SUFFIX_CURL_OFF_T     LL
+#  define CURL_SUFFIX_CURL_OFF_TU    ULL
+#  define CURL_TYPEOF_CURL_SOCKLEN_T socklen_t
+#  define CURL_PULL_SYS_TYPES_H      1
+#  define CURL_PULL_SYS_SOCKET_H     1
+
+#elif defined(__SUNPRO_C) || defined(__SUNPRO_CC) /* Oracle Solaris Studio */
+#  if !defined(__LP64) && (defined(__ILP32) ||                          \
+                           defined(__i386) ||                           \
+                           defined(__sparcv8) ||                        \
+                           defined(__sparcv8plus))
+#    define CURL_TYPEOF_CURL_OFF_T     long long
+#    define CURL_FORMAT_CURL_OFF_T     "lld"
+#    define CURL_FORMAT_CURL_OFF_TU    "llu"
+#    define CURL_SUFFIX_CURL_OFF_T     LL
+#    define CURL_SUFFIX_CURL_OFF_TU    ULL
+#  elif defined(__LP64) || \
+        defined(__amd64) || defined(__sparcv9)
+#    define CURL_TYPEOF_CURL_OFF_T     long
+#    define CURL_FORMAT_CURL_OFF_T     "ld"
+#    define CURL_FORMAT_CURL_OFF_TU    "lu"
+#    define CURL_SUFFIX_CURL_OFF_T     L
+#    define CURL_SUFFIX_CURL_OFF_TU    UL
+#  endif
+#  define CURL_TYPEOF_CURL_SOCKLEN_T socklen_t
+#  define CURL_PULL_SYS_TYPES_H      1
+#  define CURL_PULL_SYS_SOCKET_H     1
+
+#elif defined(__xlc__) /* IBM xlc compiler */
+#  if !defined(_LP64)
+#    define CURL_TYPEOF_CURL_OFF_T     long long
+#    define CURL_FORMAT_CURL_OFF_T     "lld"
+#    define CURL_FORMAT_CURL_OFF_TU    "llu"
+#    define CURL_SUFFIX_CURL_OFF_T     LL
+#    define CURL_SUFFIX_CURL_OFF_TU    ULL
+#  else
+#    define CURL_TYPEOF_CURL_OFF_T     long
+#    define CURL_FORMAT_CURL_OFF_T     "ld"
+#    define CURL_FORMAT_CURL_OFF_TU    "lu"
+#    define CURL_SUFFIX_CURL_OFF_T     L
+#    define CURL_SUFFIX_CURL_OFF_TU    UL
+#  endif
+#  define CURL_TYPEOF_CURL_SOCKLEN_T socklen_t
+#  define CURL_PULL_SYS_TYPES_H      1
+#  define CURL_PULL_SYS_SOCKET_H     1
+
+/* ===================================== */
+/*    KEEP MSVC THE PENULTIMATE ENTRY    */
+/* ===================================== */
+
+#elif defined(_MSC_VER)
+#  if (_MSC_VER >= 900) && (_INTEGRAL_MAX_BITS >= 64)
+#    define CURL_TYPEOF_CURL_OFF_T     __int64
+#    define CURL_FORMAT_CURL_OFF_T     "I64d"
+#    define CURL_FORMAT_CURL_OFF_TU    "I64u"
+#    define CURL_SUFFIX_CURL_OFF_T     i64
+#    define CURL_SUFFIX_CURL_OFF_TU    ui64
+#  else
+#    define CURL_TYPEOF_CURL_OFF_T     long
+#    define CURL_FORMAT_CURL_OFF_T     "ld"
+#    define CURL_FORMAT_CURL_OFF_TU    "lu"
+#    define CURL_SUFFIX_CURL_OFF_T     L
+#    define CURL_SUFFIX_CURL_OFF_TU    UL
+#  endif
+#  define CURL_TYPEOF_CURL_SOCKLEN_T int
+
+/* ===================================== */
+/*    KEEP GENERIC GCC THE LAST ENTRY    */
+/* ===================================== */
+
+#elif defined(__GNUC__) && !defined(_SCO_DS)
+#  if !defined(__LP64__) &&                                             \
+  (defined(__ILP32__) || defined(__i386__) || defined(__hppa__) ||      \
+   defined(__ppc__) || defined(__powerpc__) || defined(__arm__) ||      \
+   defined(__sparc__) || defined(__mips__) || defined(__sh__) ||        \
+   defined(__XTENSA__) ||                                               \
+   (defined(__SIZEOF_LONG__) && __SIZEOF_LONG__ == 4)  ||               \
+   (defined(__LONG_MAX__) && __LONG_MAX__ == 2147483647L))
+#    define CURL_TYPEOF_CURL_OFF_T     long long
+#    define CURL_FORMAT_CURL_OFF_T     "lld"
+#    define CURL_FORMAT_CURL_OFF_TU    "llu"
+#    define CURL_SUFFIX_CURL_OFF_T     LL
+#    define CURL_SUFFIX_CURL_OFF_TU    ULL
+#  elif defined(__LP64__) || \
+        defined(__x86_64__) || defined(__ppc64__) || defined(__sparc64__) || \
+        defined(__e2k__) || \
+        (defined(__SIZEOF_LONG__) && __SIZEOF_LONG__ == 8) || \
+        (defined(__LONG_MAX__) && __LONG_MAX__ == 9223372036854775807L)
+#    define CURL_TYPEOF_CURL_OFF_T     long
+#    define CURL_FORMAT_CURL_OFF_T     "ld"
+#    define CURL_FORMAT_CURL_OFF_TU    "lu"
+#    define CURL_SUFFIX_CURL_OFF_T     L
+#    define CURL_SUFFIX_CURL_OFF_TU    UL
+#  endif
+#  define CURL_TYPEOF_CURL_SOCKLEN_T socklen_t
+#  define CURL_PULL_SYS_TYPES_H      1
+#  define CURL_PULL_SYS_SOCKET_H     1
+
+#else
+/* generic "safe guess" on old 32 bit style */
+# define CURL_TYPEOF_CURL_OFF_T     long
+# define CURL_FORMAT_CURL_OFF_T     "ld"
+# define CURL_FORMAT_CURL_OFF_TU    "lu"
+# define CURL_SUFFIX_CURL_OFF_T     L
+# define CURL_SUFFIX_CURL_OFF_TU    UL
+# define CURL_TYPEOF_CURL_SOCKLEN_T int
+#endif
+
+#ifdef _AIX
+/* AIX needs <sys/poll.h> */
+#define CURL_PULL_SYS_POLL_H
+#endif
+
+
+/* CURL_PULL_WS2TCPIP_H is defined above when inclusion of header file  */
+/* ws2tcpip.h is required here to properly make type definitions below. */
+#ifdef CURL_PULL_WS2TCPIP_H
+#  include <winsock2.h>
+#  include <windows.h>
+#  include <ws2tcpip.h>
+#endif
+
+/* CURL_PULL_SYS_TYPES_H is defined above when inclusion of header file  */
+/* sys/types.h is required here to properly make type definitions below. */
+#ifdef CURL_PULL_SYS_TYPES_H
+#  include <sys/types.h>
+#endif
+
+/* CURL_PULL_SYS_SOCKET_H is defined above when inclusion of header file  */
+/* sys/socket.h is required here to properly make type definitions below. */
+#ifdef CURL_PULL_SYS_SOCKET_H
+#  include <sys/socket.h>
+#endif
+
+/* CURL_PULL_SYS_POLL_H is defined above when inclusion of header file    */
+/* sys/poll.h is required here to properly make type definitions below.   */
+#ifdef CURL_PULL_SYS_POLL_H
+#  include <sys/poll.h>
+#endif
+
+/* Data type definition of curl_socklen_t. */
+#ifdef CURL_TYPEOF_CURL_SOCKLEN_T
+  typedef CURL_TYPEOF_CURL_SOCKLEN_T curl_socklen_t;
+#endif
+
+/* Data type definition of curl_off_t. */
+
+#ifdef CURL_TYPEOF_CURL_OFF_T
+  typedef CURL_TYPEOF_CURL_OFF_T curl_off_t;
+#endif
+
+/*
+ * CURL_ISOCPP and CURL_OFF_T_C definitions are done here in order to allow
+ * these to be visible and exported by the external libcurl interface API,
+ * while also making them visible to the library internals, simply including
+ * curl_setup.h, without actually needing to include curl.h internally.
+ * If some day this section would grow big enough, all this should be moved
+ * to its own header file.
+ */
+
+/*
+ * Figure out if we can use the ## preprocessor operator, which is supported
+ * by ISO/ANSI C and C++. Some compilers support it without setting __STDC__
+ * or  __cplusplus so we need to carefully check for them too.
+ */
+
+#if defined(__STDC__) || defined(_MSC_VER) || defined(__cplusplus) || \
+  defined(__HP_aCC) || defined(__BORLANDC__) || defined(__LCC__) || \
+  defined(__POCC__) || defined(__SALFORDC__) || defined(__HIGHC__) || \
+  defined(__ILEC400__)
+  /* This compiler is believed to have an ISO compatible preprocessor */
+#define CURL_ISOCPP
+#else
+  /* This compiler is believed NOT to have an ISO compatible preprocessor */
+#undef CURL_ISOCPP
+#endif
+
+/*
+ * Macros for minimum-width signed and unsigned curl_off_t integer constants.
+ */
+
+#if defined(__BORLANDC__) && (__BORLANDC__ == 0x0551)
+#  define CURLINC_OFF_T_C_HLPR2(x) x
+#  define CURLINC_OFF_T_C_HLPR1(x) CURLINC_OFF_T_C_HLPR2(x)
+#  define CURL_OFF_T_C(Val)  CURLINC_OFF_T_C_HLPR1(Val) ## \
+                             CURLINC_OFF_T_C_HLPR1(CURL_SUFFIX_CURL_OFF_T)
+#  define CURL_OFF_TU_C(Val) CURLINC_OFF_T_C_HLPR1(Val) ## \
+                             CURLINC_OFF_T_C_HLPR1(CURL_SUFFIX_CURL_OFF_TU)
+#else
+#  ifdef CURL_ISOCPP
+#    define CURLINC_OFF_T_C_HLPR2(Val,Suffix) Val ## Suffix
+#  else
+#    define CURLINC_OFF_T_C_HLPR2(Val,Suffix) Val/**/Suffix
+#  endif
+#  define CURLINC_OFF_T_C_HLPR1(Val,Suffix) CURLINC_OFF_T_C_HLPR2(Val,Suffix)
+#  define CURL_OFF_T_C(Val)  CURLINC_OFF_T_C_HLPR1(Val,CURL_SUFFIX_CURL_OFF_T)
+#  define CURL_OFF_TU_C(Val) CURLINC_OFF_T_C_HLPR1(Val,CURL_SUFFIX_CURL_OFF_TU)
+#endif
+
+#endif /* CURLINC_SYSTEM_H */

EscapeTheBackroomsGUiTest/vcpkg_Out/include/curl/typecheck-gcc.h

@@ -0,0 +1,712 @@
+#ifndef CURLINC_TYPECHECK_GCC_H
+#define CURLINC_TYPECHECK_GCC_H
+/***************************************************************************
+ *                                  _   _ ____  _
+ *  Project                     ___| | | |  _ \| |
+ *                             / __| | | | |_) | |
+ *                            | (__| |_| |  _ <| |___
+ *                             \___|\___/|_| \_\_____|
+ *
+ * Copyright (C) 1998 - 2022, Daniel Stenberg, <daniel@haxx.se>, et al.
+ *
+ * This software is licensed as described in the file COPYING, which
+ * you should have received as part of this distribution. The terms
+ * are also available at https://curl.se/docs/copyright.html.
+ *
+ * You may opt to use, copy, modify, merge, publish, distribute and/or sell
+ * copies of the Software, and permit persons to whom the Software is
+ * furnished to do so, under the terms of the COPYING file.
+ *
+ * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
+ * KIND, either express or implied.
+ *
+ * SPDX-License-Identifier: curl
+ *
+ ***************************************************************************/
+
+/* wraps curl_easy_setopt() with typechecking */
+
+/* To add a new kind of warning, add an
+ *   if(curlcheck_sometype_option(_curl_opt))
+ *     if(!curlcheck_sometype(value))
+ *       _curl_easy_setopt_err_sometype();
+ * block and define curlcheck_sometype_option, curlcheck_sometype and
+ * _curl_easy_setopt_err_sometype below
+ *
+ * NOTE: We use two nested 'if' statements here instead of the && operator, in
+ *       order to work around gcc bug #32061.  It affects only gcc 4.3.x/4.4.x
+ *       when compiling with -Wlogical-op.
+ *
+ * To add an option that uses the same type as an existing option, you'll just
+ * need to extend the appropriate _curl_*_option macro
+ */
+#define curl_easy_setopt(handle, option, value)                         \
+  __extension__({                                                       \
+      __typeof__(option) _curl_opt = option;                            \
+      if(__builtin_constant_p(_curl_opt)) {                             \
+        if(curlcheck_long_option(_curl_opt))                            \
+          if(!curlcheck_long(value))                                    \
+            _curl_easy_setopt_err_long();                               \
+        if(curlcheck_off_t_option(_curl_opt))                           \
+          if(!curlcheck_off_t(value))                                   \
+            _curl_easy_setopt_err_curl_off_t();                         \
+        if(curlcheck_string_option(_curl_opt))                          \
+          if(!curlcheck_string(value))                                  \
+            _curl_easy_setopt_err_string();                             \
+        if(curlcheck_write_cb_option(_curl_opt))                        \
+          if(!curlcheck_write_cb(value))                                \
+            _curl_easy_setopt_err_write_callback();                     \
+        if((_curl_opt) == CURLOPT_RESOLVER_START_FUNCTION)              \
+          if(!curlcheck_resolver_start_callback(value))                 \
+            _curl_easy_setopt_err_resolver_start_callback();            \
+        if((_curl_opt) == CURLOPT_READFUNCTION)                         \
+          if(!curlcheck_read_cb(value))                                 \
+            _curl_easy_setopt_err_read_cb();                            \
+        if((_curl_opt) == CURLOPT_IOCTLFUNCTION)                        \
+          if(!curlcheck_ioctl_cb(value))                                \
+            _curl_easy_setopt_err_ioctl_cb();                           \
+        if((_curl_opt) == CURLOPT_SOCKOPTFUNCTION)                      \
+          if(!curlcheck_sockopt_cb(value))                              \
+            _curl_easy_setopt_err_sockopt_cb();                         \
+        if((_curl_opt) == CURLOPT_OPENSOCKETFUNCTION)                   \
+          if(!curlcheck_opensocket_cb(value))                           \
+            _curl_easy_setopt_err_opensocket_cb();                      \
+        if((_curl_opt) == CURLOPT_PROGRESSFUNCTION)                     \
+          if(!curlcheck_progress_cb(value))                             \
+            _curl_easy_setopt_err_progress_cb();                        \
+        if((_curl_opt) == CURLOPT_DEBUGFUNCTION)                        \
+          if(!curlcheck_debug_cb(value))                                \
+            _curl_easy_setopt_err_debug_cb();                           \
+        if((_curl_opt) == CURLOPT_SSL_CTX_FUNCTION)                     \
+          if(!curlcheck_ssl_ctx_cb(value))                              \
+            _curl_easy_setopt_err_ssl_ctx_cb();                         \
+        if(curlcheck_conv_cb_option(_curl_opt))                         \
+          if(!curlcheck_conv_cb(value))                                 \
+            _curl_easy_setopt_err_conv_cb();                            \
+        if((_curl_opt) == CURLOPT_SEEKFUNCTION)                         \
+          if(!curlcheck_seek_cb(value))                                 \
+            _curl_easy_setopt_err_seek_cb();                            \
+        if(curlcheck_cb_data_option(_curl_opt))                         \
+          if(!curlcheck_cb_data(value))                                 \
+            _curl_easy_setopt_err_cb_data();                            \
+        if((_curl_opt) == CURLOPT_ERRORBUFFER)                          \
+          if(!curlcheck_error_buffer(value))                            \
+            _curl_easy_setopt_err_error_buffer();                       \
+        if((_curl_opt) == CURLOPT_STDERR)                               \
+          if(!curlcheck_FILE(value))                                    \
+            _curl_easy_setopt_err_FILE();                               \
+        if(curlcheck_postfields_option(_curl_opt))                      \
+          if(!curlcheck_postfields(value))                              \
+            _curl_easy_setopt_err_postfields();                         \
+        if((_curl_opt) == CURLOPT_HTTPPOST)                             \
+          if(!curlcheck_arr((value), struct curl_httppost))             \
+            _curl_easy_setopt_err_curl_httpost();                       \
+        if((_curl_opt) == CURLOPT_MIMEPOST)                             \
+          if(!curlcheck_ptr((value), curl_mime))                        \
+            _curl_easy_setopt_err_curl_mimepost();                      \
+        if(curlcheck_slist_option(_curl_opt))                           \
+          if(!curlcheck_arr((value), struct curl_slist))                \
+            _curl_easy_setopt_err_curl_slist();                         \
+        if((_curl_opt) == CURLOPT_SHARE)                                \
+          if(!curlcheck_ptr((value), CURLSH))                           \
+            _curl_easy_setopt_err_CURLSH();                             \
+      }                                                                 \
+      curl_easy_setopt(handle, _curl_opt, value);                       \
+    })
+
+/* wraps curl_easy_getinfo() with typechecking */
+#define curl_easy_getinfo(handle, info, arg)                            \
+  __extension__({                                                      \
+      __typeof__(info) _curl_info = info;                               \
+      if(__builtin_constant_p(_curl_info)) {                            \
+        if(curlcheck_string_info(_curl_info))                           \
+          if(!curlcheck_arr((arg), char *))                             \
+            _curl_easy_getinfo_err_string();                            \
+        if(curlcheck_long_info(_curl_info))                             \
+          if(!curlcheck_arr((arg), long))                               \
+            _curl_easy_getinfo_err_long();                              \
+        if(curlcheck_double_info(_curl_info))                           \
+          if(!curlcheck_arr((arg), double))                             \
+            _curl_easy_getinfo_err_double();                            \
+        if(curlcheck_slist_info(_curl_info))                            \
+          if(!curlcheck_arr((arg), struct curl_slist *))                \
+            _curl_easy_getinfo_err_curl_slist();                        \
+        if(curlcheck_tlssessioninfo_info(_curl_info))                   \
+          if(!curlcheck_arr((arg), struct curl_tlssessioninfo *))       \
+            _curl_easy_getinfo_err_curl_tlssesssioninfo();              \
+        if(curlcheck_certinfo_info(_curl_info))                         \
+          if(!curlcheck_arr((arg), struct curl_certinfo *))             \
+            _curl_easy_getinfo_err_curl_certinfo();                     \
+        if(curlcheck_socket_info(_curl_info))                           \
+          if(!curlcheck_arr((arg), curl_socket_t))                      \
+            _curl_easy_getinfo_err_curl_socket();                       \
+        if(curlcheck_off_t_info(_curl_info))                            \
+          if(!curlcheck_arr((arg), curl_off_t))                         \
+            _curl_easy_getinfo_err_curl_off_t();                        \
+      }                                                                 \
+      curl_easy_getinfo(handle, _curl_info, arg);                       \
+    })
+
+/*
+ * For now, just make sure that the functions are called with three arguments
+ */
+#define curl_share_setopt(share,opt,param) curl_share_setopt(share,opt,param)
+#define curl_multi_setopt(handle,opt,param) curl_multi_setopt(handle,opt,param)
+
+
+/* the actual warnings, triggered by calling the _curl_easy_setopt_err*
+ * functions */
+
+/* To define a new warning, use _CURL_WARNING(identifier, "message") */
+#define CURLWARNING(id, message)                                        \
+  static void __attribute__((__warning__(message)))                     \
+  __attribute__((__unused__)) __attribute__((__noinline__))             \
+  id(void) { __asm__(""); }
+
+CURLWARNING(_curl_easy_setopt_err_long,
+  "curl_easy_setopt expects a long argument for this option")
+CURLWARNING(_curl_easy_setopt_err_curl_off_t,
+  "curl_easy_setopt expects a curl_off_t argument for this option")
+CURLWARNING(_curl_easy_setopt_err_string,
+              "curl_easy_setopt expects a "
+              "string ('char *' or char[]) argument for this option"
+  )
+CURLWARNING(_curl_easy_setopt_err_write_callback,
+  "curl_easy_setopt expects a curl_write_callback argument for this option")
+CURLWARNING(_curl_easy_setopt_err_resolver_start_callback,
+              "curl_easy_setopt expects a "
+              "curl_resolver_start_callback argument for this option"
+  )
+CURLWARNING(_curl_easy_setopt_err_read_cb,
+  "curl_easy_setopt expects a curl_read_callback argument for this option")
+CURLWARNING(_curl_easy_setopt_err_ioctl_cb,
+  "curl_easy_setopt expects a curl_ioctl_callback argument for this option")
+CURLWARNING(_curl_easy_setopt_err_sockopt_cb,
+  "curl_easy_setopt expects a curl_sockopt_callback argument for this option")
+CURLWARNING(_curl_easy_setopt_err_opensocket_cb,
+              "curl_easy_setopt expects a "
+              "curl_opensocket_callback argument for this option"
+  )
+CURLWARNING(_curl_easy_setopt_err_progress_cb,
+  "curl_easy_setopt expects a curl_progress_callback argument for this option")
+CURLWARNING(_curl_easy_setopt_err_debug_cb,
+  "curl_easy_setopt expects a curl_debug_callback argument for this option")
+CURLWARNING(_curl_easy_setopt_err_ssl_ctx_cb,
+  "curl_easy_setopt expects a curl_ssl_ctx_callback argument for this option")
+CURLWARNING(_curl_easy_setopt_err_conv_cb,
+  "curl_easy_setopt expects a curl_conv_callback argument for this option")
+CURLWARNING(_curl_easy_setopt_err_seek_cb,
+  "curl_easy_setopt expects a curl_seek_callback argument for this option")
+CURLWARNING(_curl_easy_setopt_err_cb_data,
+              "curl_easy_setopt expects a "
+              "private data pointer as argument for this option")
+CURLWARNING(_curl_easy_setopt_err_error_buffer,
+              "curl_easy_setopt expects a "
+              "char buffer of CURL_ERROR_SIZE as argument for this option")
+CURLWARNING(_curl_easy_setopt_err_FILE,
+  "curl_easy_setopt expects a 'FILE *' argument for this option")
+CURLWARNING(_curl_easy_setopt_err_postfields,
+  "curl_easy_setopt expects a 'void *' or 'char *' argument for this option")
+CURLWARNING(_curl_easy_setopt_err_curl_httpost,
+              "curl_easy_setopt expects a 'struct curl_httppost *' "
+              "argument for this option")
+CURLWARNING(_curl_easy_setopt_err_curl_mimepost,
+              "curl_easy_setopt expects a 'curl_mime *' "
+              "argument for this option")
+CURLWARNING(_curl_easy_setopt_err_curl_slist,
+  "curl_easy_setopt expects a 'struct curl_slist *' argument for this option")
+CURLWARNING(_curl_easy_setopt_err_CURLSH,
+  "curl_easy_setopt expects a CURLSH* argument for this option")
+
+CURLWARNING(_curl_easy_getinfo_err_string,
+  "curl_easy_getinfo expects a pointer to 'char *' for this info")
+CURLWARNING(_curl_easy_getinfo_err_long,
+  "curl_easy_getinfo expects a pointer to long for this info")
+CURLWARNING(_curl_easy_getinfo_err_double,
+  "curl_easy_getinfo expects a pointer to double for this info")
+CURLWARNING(_curl_easy_getinfo_err_curl_slist,
+  "curl_easy_getinfo expects a pointer to 'struct curl_slist *' for this info")
+CURLWARNING(_curl_easy_getinfo_err_curl_tlssesssioninfo,
+              "curl_easy_getinfo expects a pointer to "
+              "'struct curl_tlssessioninfo *' for this info")
+CURLWARNING(_curl_easy_getinfo_err_curl_certinfo,
+              "curl_easy_getinfo expects a pointer to "
+              "'struct curl_certinfo *' for this info")
+CURLWARNING(_curl_easy_getinfo_err_curl_socket,
+  "curl_easy_getinfo expects a pointer to curl_socket_t for this info")
+CURLWARNING(_curl_easy_getinfo_err_curl_off_t,
+  "curl_easy_getinfo expects a pointer to curl_off_t for this info")
+
+/* groups of curl_easy_setops options that take the same type of argument */
+
+/* To add a new option to one of the groups, just add
+ *   (option) == CURLOPT_SOMETHING
+ * to the or-expression. If the option takes a long or curl_off_t, you don't
+ * have to do anything
+ */
+
+/* evaluates to true if option takes a long argument */
+#define curlcheck_long_option(option)                   \
+  (0 < (option) && (option) < CURLOPTTYPE_OBJECTPOINT)
+
+#define curlcheck_off_t_option(option)          \
+  (((option) > CURLOPTTYPE_OFF_T) && ((option) < CURLOPTTYPE_BLOB))
+
+/* evaluates to true if option takes a char* argument */
+#define curlcheck_string_option(option)                                       \
+  ((option) == CURLOPT_ABSTRACT_UNIX_SOCKET ||                                \
+   (option) == CURLOPT_ACCEPT_ENCODING ||                                     \
+   (option) == CURLOPT_ALTSVC ||                                              \
+   (option) == CURLOPT_CAINFO ||                                              \
+   (option) == CURLOPT_CAPATH ||                                              \
+   (option) == CURLOPT_COOKIE ||                                              \
+   (option) == CURLOPT_COOKIEFILE ||                                          \
+   (option) == CURLOPT_COOKIEJAR ||                                           \
+   (option) == CURLOPT_COOKIELIST ||                                          \
+   (option) == CURLOPT_CRLFILE ||                                             \
+   (option) == CURLOPT_CUSTOMREQUEST ||                                       \
+   (option) == CURLOPT_DEFAULT_PROTOCOL ||                                    \
+   (option) == CURLOPT_DNS_INTERFACE ||                                       \
+   (option) == CURLOPT_DNS_LOCAL_IP4 ||                                       \
+   (option) == CURLOPT_DNS_LOCAL_IP6 ||                                       \
+   (option) == CURLOPT_DNS_SERVERS ||                                         \
+   (option) == CURLOPT_DOH_URL ||                                             \
+   (option) == CURLOPT_EGDSOCKET ||                                           \
+   (option) == CURLOPT_FTP_ACCOUNT ||                                         \
+   (option) == CURLOPT_FTP_ALTERNATIVE_TO_USER ||                             \
+   (option) == CURLOPT_FTPPORT ||                                             \
+   (option) == CURLOPT_HSTS ||                                                \
+   (option) == CURLOPT_INTERFACE ||                                           \
+   (option) == CURLOPT_ISSUERCERT ||                                          \
+   (option) == CURLOPT_KEYPASSWD ||                                           \
+   (option) == CURLOPT_KRBLEVEL ||                                            \
+   (option) == CURLOPT_LOGIN_OPTIONS ||                                       \
+   (option) == CURLOPT_MAIL_AUTH ||                                           \
+   (option) == CURLOPT_MAIL_FROM ||                                           \
+   (option) == CURLOPT_NETRC_FILE ||                                          \
+   (option) == CURLOPT_NOPROXY ||                                             \
+   (option) == CURLOPT_PASSWORD ||                                            \
+   (option) == CURLOPT_PINNEDPUBLICKEY ||                                     \
+   (option) == CURLOPT_PRE_PROXY ||                                           \
+   (option) == CURLOPT_PROTOCOLS_STR ||                                       \
+   (option) == CURLOPT_PROXY ||                                               \
+   (option) == CURLOPT_PROXY_CAINFO ||                                        \
+   (option) == CURLOPT_PROXY_CAPATH ||                                        \
+   (option) == CURLOPT_PROXY_CRLFILE ||                                       \
+   (option) == CURLOPT_PROXY_ISSUERCERT ||                                    \
+   (option) == CURLOPT_PROXY_KEYPASSWD ||                                     \
+   (option) == CURLOPT_PROXY_PINNEDPUBLICKEY ||                               \
+   (option) == CURLOPT_PROXY_SERVICE_NAME ||                                  \
+   (option) == CURLOPT_PROXY_SSL_CIPHER_LIST ||                               \
+   (option) == CURLOPT_PROXY_SSLCERT ||                                       \
+   (option) == CURLOPT_PROXY_SSLCERTTYPE ||                                   \
+   (option) == CURLOPT_PROXY_SSLKEY ||                                        \
+   (option) == CURLOPT_PROXY_SSLKEYTYPE ||                                    \
+   (option) == CURLOPT_PROXY_TLS13_CIPHERS ||                                 \
+   (option) == CURLOPT_PROXY_TLSAUTH_PASSWORD ||                              \
+   (option) == CURLOPT_PROXY_TLSAUTH_TYPE ||                                  \
+   (option) == CURLOPT_PROXY_TLSAUTH_USERNAME ||                              \
+   (option) == CURLOPT_PROXYPASSWORD ||                                       \
+   (option) == CURLOPT_PROXYUSERNAME ||                                       \
+   (option) == CURLOPT_PROXYUSERPWD ||                                        \
+   (option) == CURLOPT_RANDOM_FILE ||                                         \
+   (option) == CURLOPT_RANGE ||                                               \
+   (option) == CURLOPT_REDIR_PROTOCOLS_STR ||                                 \
+   (option) == CURLOPT_REFERER ||                                             \
+   (option) == CURLOPT_REQUEST_TARGET ||                                      \
+   (option) == CURLOPT_RTSP_SESSION_ID ||                                     \
+   (option) == CURLOPT_RTSP_STREAM_URI ||                                     \
+   (option) == CURLOPT_RTSP_TRANSPORT ||                                      \
+   (option) == CURLOPT_SASL_AUTHZID ||                                        \
+   (option) == CURLOPT_SERVICE_NAME ||                                        \
+   (option) == CURLOPT_SOCKS5_GSSAPI_SERVICE ||                               \
+   (option) == CURLOPT_SSH_HOST_PUBLIC_KEY_MD5 ||                             \
+   (option) == CURLOPT_SSH_HOST_PUBLIC_KEY_SHA256 ||                          \
+   (option) == CURLOPT_SSH_KNOWNHOSTS ||                                      \
+   (option) == CURLOPT_SSH_PRIVATE_KEYFILE ||                                 \
+   (option) == CURLOPT_SSH_PUBLIC_KEYFILE ||                                  \
+   (option) == CURLOPT_SSLCERT ||                                             \
+   (option) == CURLOPT_SSLCERTTYPE ||                                         \
+   (option) == CURLOPT_SSLENGINE ||                                           \
+   (option) == CURLOPT_SSLKEY ||                                              \
+   (option) == CURLOPT_SSLKEYTYPE ||                                          \
+   (option) == CURLOPT_SSL_CIPHER_LIST ||                                     \
+   (option) == CURLOPT_TLS13_CIPHERS ||                                       \
+   (option) == CURLOPT_TLSAUTH_PASSWORD ||                                    \
+   (option) == CURLOPT_TLSAUTH_TYPE ||                                        \
+   (option) == CURLOPT_TLSAUTH_USERNAME ||                                    \
+   (option) == CURLOPT_UNIX_SOCKET_PATH ||                                    \
+   (option) == CURLOPT_URL ||                                                 \
+   (option) == CURLOPT_USERAGENT ||                                           \
+   (option) == CURLOPT_USERNAME ||                                            \
+   (option) == CURLOPT_AWS_SIGV4 ||                                           \
+   (option) == CURLOPT_USERPWD ||                                             \
+   (option) == CURLOPT_XOAUTH2_BEARER ||                                      \
+   (option) == CURLOPT_SSL_EC_CURVES ||                                       \
+   0)
+
+/* evaluates to true if option takes a curl_write_callback argument */
+#define curlcheck_write_cb_option(option)                               \
+  ((option) == CURLOPT_HEADERFUNCTION ||                                \
+   (option) == CURLOPT_WRITEFUNCTION)
+
+/* evaluates to true if option takes a curl_conv_callback argument */
+#define curlcheck_conv_cb_option(option)                                \
+  ((option) == CURLOPT_CONV_TO_NETWORK_FUNCTION ||                      \
+   (option) == CURLOPT_CONV_FROM_NETWORK_FUNCTION ||                    \
+   (option) == CURLOPT_CONV_FROM_UTF8_FUNCTION)
+
+/* evaluates to true if option takes a data argument to pass to a callback */
+#define curlcheck_cb_data_option(option)                                      \
+  ((option) == CURLOPT_CHUNK_DATA ||                                          \
+   (option) == CURLOPT_CLOSESOCKETDATA ||                                     \
+   (option) == CURLOPT_DEBUGDATA ||                                           \
+   (option) == CURLOPT_FNMATCH_DATA ||                                        \
+   (option) == CURLOPT_HEADERDATA ||                                          \
+   (option) == CURLOPT_HSTSREADDATA ||                                        \
+   (option) == CURLOPT_HSTSWRITEDATA ||                                       \
+   (option) == CURLOPT_INTERLEAVEDATA ||                                      \
+   (option) == CURLOPT_IOCTLDATA ||                                           \
+   (option) == CURLOPT_OPENSOCKETDATA ||                                      \
+   (option) == CURLOPT_PREREQDATA ||                                          \
+   (option) == CURLOPT_PROGRESSDATA ||                                        \
+   (option) == CURLOPT_READDATA ||                                            \
+   (option) == CURLOPT_SEEKDATA ||                                            \
+   (option) == CURLOPT_SOCKOPTDATA ||                                         \
+   (option) == CURLOPT_SSH_KEYDATA ||                                         \
+   (option) == CURLOPT_SSL_CTX_DATA ||                                        \
+   (option) == CURLOPT_WRITEDATA ||                                           \
+   (option) == CURLOPT_RESOLVER_START_DATA ||                                 \
+   (option) == CURLOPT_TRAILERDATA ||                                         \
+   (option) == CURLOPT_SSH_HOSTKEYDATA ||                                     \
+   0)
+
+/* evaluates to true if option takes a POST data argument (void* or char*) */
+#define curlcheck_postfields_option(option)                                   \
+  ((option) == CURLOPT_POSTFIELDS ||                                          \
+   (option) == CURLOPT_COPYPOSTFIELDS ||                                      \
+   0)
+
+/* evaluates to true if option takes a struct curl_slist * argument */
+#define curlcheck_slist_option(option)                                        \
+  ((option) == CURLOPT_HTTP200ALIASES ||                                      \
+   (option) == CURLOPT_HTTPHEADER ||                                          \
+   (option) == CURLOPT_MAIL_RCPT ||                                           \
+   (option) == CURLOPT_POSTQUOTE ||                                           \
+   (option) == CURLOPT_PREQUOTE ||                                            \
+   (option) == CURLOPT_PROXYHEADER ||                                         \
+   (option) == CURLOPT_QUOTE ||                                               \
+   (option) == CURLOPT_RESOLVE ||                                             \
+   (option) == CURLOPT_TELNETOPTIONS ||                                       \
+   (option) == CURLOPT_CONNECT_TO ||                                          \
+   0)
+
+/* groups of curl_easy_getinfo infos that take the same type of argument */
+
+/* evaluates to true if info expects a pointer to char * argument */
+#define curlcheck_string_info(info)                             \
+  (CURLINFO_STRING < (info) && (info) < CURLINFO_LONG &&        \
+   (info) != CURLINFO_PRIVATE)
+
+/* evaluates to true if info expects a pointer to long argument */
+#define curlcheck_long_info(info)                       \
+  (CURLINFO_LONG < (info) && (info) < CURLINFO_DOUBLE)
+
+/* evaluates to true if info expects a pointer to double argument */
+#define curlcheck_double_info(info)                     \
+  (CURLINFO_DOUBLE < (info) && (info) < CURLINFO_SLIST)
+
+/* true if info expects a pointer to struct curl_slist * argument */
+#define curlcheck_slist_info(info)                                      \
+  (((info) == CURLINFO_SSL_ENGINES) || ((info) == CURLINFO_COOKIELIST))
+
+/* true if info expects a pointer to struct curl_tlssessioninfo * argument */
+#define curlcheck_tlssessioninfo_info(info)                              \
+  (((info) == CURLINFO_TLS_SSL_PTR) || ((info) == CURLINFO_TLS_SESSION))
+
+/* true if info expects a pointer to struct curl_certinfo * argument */
+#define curlcheck_certinfo_info(info) ((info) == CURLINFO_CERTINFO)
+
+/* true if info expects a pointer to struct curl_socket_t argument */
+#define curlcheck_socket_info(info)                     \
+  (CURLINFO_SOCKET < (info) && (info) < CURLINFO_OFF_T)
+
+/* true if info expects a pointer to curl_off_t argument */
+#define curlcheck_off_t_info(info)              \
+  (CURLINFO_OFF_T < (info))
+
+
+/* typecheck helpers -- check whether given expression has requested type*/
+
+/* For pointers, you can use the curlcheck_ptr/curlcheck_arr macros,
+ * otherwise define a new macro. Search for __builtin_types_compatible_p
+ * in the GCC manual.
+ * NOTE: these macros MUST NOT EVALUATE their arguments! The argument is
+ * the actual expression passed to the curl_easy_setopt macro. This
+ * means that you can only apply the sizeof and __typeof__ operators, no
+ * == or whatsoever.
+ */
+
+/* XXX: should evaluate to true if expr is a pointer */
+#define curlcheck_any_ptr(expr)                 \
+  (sizeof(expr) == sizeof(void *))
+
+/* evaluates to true if expr is NULL */
+/* XXX: must not evaluate expr, so this check is not accurate */
+#define curlcheck_NULL(expr)                                            \
+  (__builtin_types_compatible_p(__typeof__(expr), __typeof__(NULL)))
+
+/* evaluates to true if expr is type*, const type* or NULL */
+#define curlcheck_ptr(expr, type)                                       \
+  (curlcheck_NULL(expr) ||                                              \
+   __builtin_types_compatible_p(__typeof__(expr), type *) ||            \
+   __builtin_types_compatible_p(__typeof__(expr), const type *))
+
+/* evaluates to true if expr is one of type[], type*, NULL or const type* */
+#define curlcheck_arr(expr, type)                                       \
+  (curlcheck_ptr((expr), type) ||                                       \
+   __builtin_types_compatible_p(__typeof__(expr), type []))
+
+/* evaluates to true if expr is a string */
+#define curlcheck_string(expr)                                          \
+  (curlcheck_arr((expr), char) ||                                       \
+   curlcheck_arr((expr), signed char) ||                                \
+   curlcheck_arr((expr), unsigned char))
+
+/* evaluates to true if expr is a long (no matter the signedness)
+ * XXX: for now, int is also accepted (and therefore short and char, which
+ * are promoted to int when passed to a variadic function) */
+#define curlcheck_long(expr)                                                  \
+  (__builtin_types_compatible_p(__typeof__(expr), long) ||                    \
+   __builtin_types_compatible_p(__typeof__(expr), signed long) ||             \
+   __builtin_types_compatible_p(__typeof__(expr), unsigned long) ||           \
+   __builtin_types_compatible_p(__typeof__(expr), int) ||                     \
+   __builtin_types_compatible_p(__typeof__(expr), signed int) ||              \
+   __builtin_types_compatible_p(__typeof__(expr), unsigned int) ||            \
+   __builtin_types_compatible_p(__typeof__(expr), short) ||                   \
+   __builtin_types_compatible_p(__typeof__(expr), signed short) ||            \
+   __builtin_types_compatible_p(__typeof__(expr), unsigned short) ||          \
+   __builtin_types_compatible_p(__typeof__(expr), char) ||                    \
+   __builtin_types_compatible_p(__typeof__(expr), signed char) ||             \
+   __builtin_types_compatible_p(__typeof__(expr), unsigned char))
+
+/* evaluates to true if expr is of type curl_off_t */
+#define curlcheck_off_t(expr)                                   \
+  (__builtin_types_compatible_p(__typeof__(expr), curl_off_t))
+
+/* evaluates to true if expr is abuffer suitable for CURLOPT_ERRORBUFFER */
+/* XXX: also check size of an char[] array? */
+#define curlcheck_error_buffer(expr)                                    \
+  (curlcheck_NULL(expr) ||                                              \
+   __builtin_types_compatible_p(__typeof__(expr), char *) ||            \
+   __builtin_types_compatible_p(__typeof__(expr), char[]))
+
+/* evaluates to true if expr is of type (const) void* or (const) FILE* */
+#if 0
+#define curlcheck_cb_data(expr)                                         \
+  (curlcheck_ptr((expr), void) ||                                       \
+   curlcheck_ptr((expr), FILE))
+#else /* be less strict */
+#define curlcheck_cb_data(expr)                 \
+  curlcheck_any_ptr(expr)
+#endif
+
+/* evaluates to true if expr is of type FILE* */
+#define curlcheck_FILE(expr)                                            \
+  (curlcheck_NULL(expr) ||                                              \
+   (__builtin_types_compatible_p(__typeof__(expr), FILE *)))
+
+/* evaluates to true if expr can be passed as POST data (void* or char*) */
+#define curlcheck_postfields(expr)                                      \
+  (curlcheck_ptr((expr), void) ||                                       \
+   curlcheck_arr((expr), char) ||                                       \
+   curlcheck_arr((expr), unsigned char))
+
+/* helper: __builtin_types_compatible_p distinguishes between functions and
+ * function pointers, hide it */
+#define curlcheck_cb_compatible(func, type)                             \
+  (__builtin_types_compatible_p(__typeof__(func), type) ||              \
+   __builtin_types_compatible_p(__typeof__(func) *, type))
+
+/* evaluates to true if expr is of type curl_resolver_start_callback */
+#define curlcheck_resolver_start_callback(expr)       \
+  (curlcheck_NULL(expr) || \
+   curlcheck_cb_compatible((expr), curl_resolver_start_callback))
+
+/* evaluates to true if expr is of type curl_read_callback or "similar" */
+#define curlcheck_read_cb(expr)                                         \
+  (curlcheck_NULL(expr) ||                                              \
+   curlcheck_cb_compatible((expr), __typeof__(fread) *) ||              \
+   curlcheck_cb_compatible((expr), curl_read_callback) ||               \
+   curlcheck_cb_compatible((expr), _curl_read_callback1) ||             \
+   curlcheck_cb_compatible((expr), _curl_read_callback2) ||             \
+   curlcheck_cb_compatible((expr), _curl_read_callback3) ||             \
+   curlcheck_cb_compatible((expr), _curl_read_callback4) ||             \
+   curlcheck_cb_compatible((expr), _curl_read_callback5) ||             \
+   curlcheck_cb_compatible((expr), _curl_read_callback6))
+typedef size_t (*_curl_read_callback1)(char *, size_t, size_t, void *);
+typedef size_t (*_curl_read_callback2)(char *, size_t, size_t, const void *);
+typedef size_t (*_curl_read_callback3)(char *, size_t, size_t, FILE *);
+typedef size_t (*_curl_read_callback4)(void *, size_t, size_t, void *);
+typedef size_t (*_curl_read_callback5)(void *, size_t, size_t, const void *);
+typedef size_t (*_curl_read_callback6)(void *, size_t, size_t, FILE *);
+
+/* evaluates to true if expr is of type curl_write_callback or "similar" */
+#define curlcheck_write_cb(expr)                                        \
+  (curlcheck_read_cb(expr) ||                                           \
+   curlcheck_cb_compatible((expr), __typeof__(fwrite) *) ||             \
+   curlcheck_cb_compatible((expr), curl_write_callback) ||              \
+   curlcheck_cb_compatible((expr), _curl_write_callback1) ||            \
+   curlcheck_cb_compatible((expr), _curl_write_callback2) ||            \
+   curlcheck_cb_compatible((expr), _curl_write_callback3) ||            \
+   curlcheck_cb_compatible((expr), _curl_write_callback4) ||            \
+   curlcheck_cb_compatible((expr), _curl_write_callback5) ||            \
+   curlcheck_cb_compatible((expr), _curl_write_callback6))
+typedef size_t (*_curl_write_callback1)(const char *, size_t, size_t, void *);
+typedef size_t (*_curl_write_callback2)(const char *, size_t, size_t,
+                                       const void *);
+typedef size_t (*_curl_write_callback3)(const char *, size_t, size_t, FILE *);
+typedef size_t (*_curl_write_callback4)(const void *, size_t, size_t, void *);
+typedef size_t (*_curl_write_callback5)(const void *, size_t, size_t,
+                                       const void *);
+typedef size_t (*_curl_write_callback6)(const void *, size_t, size_t, FILE *);
+
+/* evaluates to true if expr is of type curl_ioctl_callback or "similar" */
+#define curlcheck_ioctl_cb(expr)                                        \
+  (curlcheck_NULL(expr) ||                                              \
+   curlcheck_cb_compatible((expr), curl_ioctl_callback) ||              \
+   curlcheck_cb_compatible((expr), _curl_ioctl_callback1) ||            \
+   curlcheck_cb_compatible((expr), _curl_ioctl_callback2) ||            \
+   curlcheck_cb_compatible((expr), _curl_ioctl_callback3) ||            \
+   curlcheck_cb_compatible((expr), _curl_ioctl_callback4))
+typedef curlioerr (*_curl_ioctl_callback1)(CURL *, int, void *);
+typedef curlioerr (*_curl_ioctl_callback2)(CURL *, int, const void *);
+typedef curlioerr (*_curl_ioctl_callback3)(CURL *, curliocmd, void *);
+typedef curlioerr (*_curl_ioctl_callback4)(CURL *, curliocmd, const void *);
+
+/* evaluates to true if expr is of type curl_sockopt_callback or "similar" */
+#define curlcheck_sockopt_cb(expr)                                      \
+  (curlcheck_NULL(expr) ||                                              \
+   curlcheck_cb_compatible((expr), curl_sockopt_callback) ||            \
+   curlcheck_cb_compatible((expr), _curl_sockopt_callback1) ||          \
+   curlcheck_cb_compatible((expr), _curl_sockopt_callback2))
+typedef int (*_curl_sockopt_callback1)(void *, curl_socket_t, curlsocktype);
+typedef int (*_curl_sockopt_callback2)(const void *, curl_socket_t,
+                                      curlsocktype);
+
+/* evaluates to true if expr is of type curl_opensocket_callback or
+   "similar" */
+#define curlcheck_opensocket_cb(expr)                                   \
+  (curlcheck_NULL(expr) ||                                              \
+   curlcheck_cb_compatible((expr), curl_opensocket_callback) ||         \
+   curlcheck_cb_compatible((expr), _curl_opensocket_callback1) ||       \
+   curlcheck_cb_compatible((expr), _curl_opensocket_callback2) ||       \
+   curlcheck_cb_compatible((expr), _curl_opensocket_callback3) ||       \
+   curlcheck_cb_compatible((expr), _curl_opensocket_callback4))
+typedef curl_socket_t (*_curl_opensocket_callback1)
+  (void *, curlsocktype, struct curl_sockaddr *);
+typedef curl_socket_t (*_curl_opensocket_callback2)
+  (void *, curlsocktype, const struct curl_sockaddr *);
+typedef curl_socket_t (*_curl_opensocket_callback3)
+  (const void *, curlsocktype, struct curl_sockaddr *);
+typedef curl_socket_t (*_curl_opensocket_callback4)
+  (const void *, curlsocktype, const struct curl_sockaddr *);
+
+/* evaluates to true if expr is of type curl_progress_callback or "similar" */
+#define curlcheck_progress_cb(expr)                                     \
+  (curlcheck_NULL(expr) ||                                              \
+   curlcheck_cb_compatible((expr), curl_progress_callback) ||           \
+   curlcheck_cb_compatible((expr), _curl_progress_callback1) ||         \
+   curlcheck_cb_compatible((expr), _curl_progress_callback2))
+typedef int (*_curl_progress_callback1)(void *,
+    double, double, double, double);
+typedef int (*_curl_progress_callback2)(const void *,
+    double, double, double, double);
+
+/* evaluates to true if expr is of type curl_debug_callback or "similar" */
+#define curlcheck_debug_cb(expr)                                        \
+  (curlcheck_NULL(expr) ||                                              \
+   curlcheck_cb_compatible((expr), curl_debug_callback) ||              \
+   curlcheck_cb_compatible((expr), _curl_debug_callback1) ||            \
+   curlcheck_cb_compatible((expr), _curl_debug_callback2) ||            \
+   curlcheck_cb_compatible((expr), _curl_debug_callback3) ||            \
+   curlcheck_cb_compatible((expr), _curl_debug_callback4) ||            \
+   curlcheck_cb_compatible((expr), _curl_debug_callback5) ||            \
+   curlcheck_cb_compatible((expr), _curl_debug_callback6) ||            \
+   curlcheck_cb_compatible((expr), _curl_debug_callback7) ||            \
+   curlcheck_cb_compatible((expr), _curl_debug_callback8))
+typedef int (*_curl_debug_callback1) (CURL *,
+    curl_infotype, char *, size_t, void *);
+typedef int (*_curl_debug_callback2) (CURL *,
+    curl_infotype, char *, size_t, const void *);
+typedef int (*_curl_debug_callback3) (CURL *,
+    curl_infotype, const char *, size_t, void *);
+typedef int (*_curl_debug_callback4) (CURL *,
+    curl_infotype, const char *, size_t, const void *);
+typedef int (*_curl_debug_callback5) (CURL *,
+    curl_infotype, unsigned char *, size_t, void *);
+typedef int (*_curl_debug_callback6) (CURL *,
+    curl_infotype, unsigned char *, size_t, const void *);
+typedef int (*_curl_debug_callback7) (CURL *,
+    curl_infotype, const unsigned char *, size_t, void *);
+typedef int (*_curl_debug_callback8) (CURL *,
+    curl_infotype, const unsigned char *, size_t, const void *);
+
+/* evaluates to true if expr is of type curl_ssl_ctx_callback or "similar" */
+/* this is getting even messier... */
+#define curlcheck_ssl_ctx_cb(expr)                                      \
+  (curlcheck_NULL(expr) ||                                              \
+   curlcheck_cb_compatible((expr), curl_ssl_ctx_callback) ||            \
+   curlcheck_cb_compatible((expr), _curl_ssl_ctx_callback1) ||          \
+   curlcheck_cb_compatible((expr), _curl_ssl_ctx_callback2) ||          \
+   curlcheck_cb_compatible((expr), _curl_ssl_ctx_callback3) ||          \
+   curlcheck_cb_compatible((expr), _curl_ssl_ctx_callback4) ||          \
+   curlcheck_cb_compatible((expr), _curl_ssl_ctx_callback5) ||          \
+   curlcheck_cb_compatible((expr), _curl_ssl_ctx_callback6) ||          \
+   curlcheck_cb_compatible((expr), _curl_ssl_ctx_callback7) ||          \
+   curlcheck_cb_compatible((expr), _curl_ssl_ctx_callback8))
+typedef CURLcode (*_curl_ssl_ctx_callback1)(CURL *, void *, void *);
+typedef CURLcode (*_curl_ssl_ctx_callback2)(CURL *, void *, const void *);
+typedef CURLcode (*_curl_ssl_ctx_callback3)(CURL *, const void *, void *);
+typedef CURLcode (*_curl_ssl_ctx_callback4)(CURL *, const void *,
+                                            const void *);
+#ifdef HEADER_SSL_H
+/* hack: if we included OpenSSL's ssl.h, we know about SSL_CTX
+ * this will of course break if we're included before OpenSSL headers...
+ */
+typedef CURLcode (*_curl_ssl_ctx_callback5)(CURL *, SSL_CTX *, void *);
+typedef CURLcode (*_curl_ssl_ctx_callback6)(CURL *, SSL_CTX *, const void *);
+typedef CURLcode (*_curl_ssl_ctx_callback7)(CURL *, const SSL_CTX *, void *);
+typedef CURLcode (*_curl_ssl_ctx_callback8)(CURL *, const SSL_CTX *,
+                                            const void *);
+#else
+typedef _curl_ssl_ctx_callback1 _curl_ssl_ctx_callback5;
+typedef _curl_ssl_ctx_callback1 _curl_ssl_ctx_callback6;
+typedef _curl_ssl_ctx_callback1 _curl_ssl_ctx_callback7;
+typedef _curl_ssl_ctx_callback1 _curl_ssl_ctx_callback8;
+#endif
+
+/* evaluates to true if expr is of type curl_conv_callback or "similar" */
+#define curlcheck_conv_cb(expr)                                         \
+  (curlcheck_NULL(expr) ||                                              \
+   curlcheck_cb_compatible((expr), curl_conv_callback) ||               \
+   curlcheck_cb_compatible((expr), _curl_conv_callback1) ||             \
+   curlcheck_cb_compatible((expr), _curl_conv_callback2) ||             \
+   curlcheck_cb_compatible((expr), _curl_conv_callback3) ||             \
+   curlcheck_cb_compatible((expr), _curl_conv_callback4))
+typedef CURLcode (*_curl_conv_callback1)(char *, size_t length);
+typedef CURLcode (*_curl_conv_callback2)(const char *, size_t length);
+typedef CURLcode (*_curl_conv_callback3)(void *, size_t length);
+typedef CURLcode (*_curl_conv_callback4)(const void *, size_t length);
+
+/* evaluates to true if expr is of type curl_seek_callback or "similar" */
+#define curlcheck_seek_cb(expr)                                         \
+  (curlcheck_NULL(expr) ||                                              \
+   curlcheck_cb_compatible((expr), curl_seek_callback) ||               \
+   curlcheck_cb_compatible((expr), _curl_seek_callback1) ||             \
+   curlcheck_cb_compatible((expr), _curl_seek_callback2))
+typedef CURLcode (*_curl_seek_callback1)(void *, curl_off_t, int);
+typedef CURLcode (*_curl_seek_callback2)(const void *, curl_off_t, int);
+
+
+#endif /* CURLINC_TYPECHECK_GCC_H */

EscapeTheBackroomsGUiTest/vcpkg_Out/include/curl/urlapi.h

@@ -0,0 +1,147 @@
+#ifndef CURLINC_URLAPI_H
+#define CURLINC_URLAPI_H
+/***************************************************************************
+ *                                  _   _ ____  _
+ *  Project                     ___| | | |  _ \| |
+ *                             / __| | | | |_) | |
+ *                            | (__| |_| |  _ <| |___
+ *                             \___|\___/|_| \_\_____|
+ *
+ * Copyright (C) 2018 - 2022, Daniel Stenberg, <daniel@haxx.se>, et al.
+ *
+ * This software is licensed as described in the file COPYING, which
+ * you should have received as part of this distribution. The terms
+ * are also available at https://curl.se/docs/copyright.html.
+ *
+ * You may opt to use, copy, modify, merge, publish, distribute and/or sell
+ * copies of the Software, and permit persons to whom the Software is
+ * furnished to do so, under the terms of the COPYING file.
+ *
+ * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
+ * KIND, either express or implied.
+ *
+ * SPDX-License-Identifier: curl
+ *
+ ***************************************************************************/
+
+#include "curl.h"
+
+#ifdef  __cplusplus
+extern "C" {
+#endif
+
+/* the error codes for the URL API */
+typedef enum {
+  CURLUE_OK,
+  CURLUE_BAD_HANDLE,          /* 1 */
+  CURLUE_BAD_PARTPOINTER,     /* 2 */
+  CURLUE_MALFORMED_INPUT,     /* 3 */
+  CURLUE_BAD_PORT_NUMBER,     /* 4 */
+  CURLUE_UNSUPPORTED_SCHEME,  /* 5 */
+  CURLUE_URLDECODE,           /* 6 */
+  CURLUE_OUT_OF_MEMORY,       /* 7 */
+  CURLUE_USER_NOT_ALLOWED,    /* 8 */
+  CURLUE_UNKNOWN_PART,        /* 9 */
+  CURLUE_NO_SCHEME,           /* 10 */
+  CURLUE_NO_USER,             /* 11 */
+  CURLUE_NO_PASSWORD,         /* 12 */
+  CURLUE_NO_OPTIONS,          /* 13 */
+  CURLUE_NO_HOST,             /* 14 */
+  CURLUE_NO_PORT,             /* 15 */
+  CURLUE_NO_QUERY,            /* 16 */
+  CURLUE_NO_FRAGMENT,         /* 17 */
+  CURLUE_NO_ZONEID,           /* 18 */
+  CURLUE_BAD_FILE_URL,        /* 19 */
+  CURLUE_BAD_FRAGMENT,        /* 20 */
+  CURLUE_BAD_HOSTNAME,        /* 21 */
+  CURLUE_BAD_IPV6,            /* 22 */
+  CURLUE_BAD_LOGIN,           /* 23 */
+  CURLUE_BAD_PASSWORD,        /* 24 */
+  CURLUE_BAD_PATH,            /* 25 */
+  CURLUE_BAD_QUERY,           /* 26 */
+  CURLUE_BAD_SCHEME,          /* 27 */
+  CURLUE_BAD_SLASHES,         /* 28 */
+  CURLUE_BAD_USER,            /* 29 */
+  CURLUE_LAST
+} CURLUcode;
+
+typedef enum {
+  CURLUPART_URL,
+  CURLUPART_SCHEME,
+  CURLUPART_USER,
+  CURLUPART_PASSWORD,
+  CURLUPART_OPTIONS,
+  CURLUPART_HOST,
+  CURLUPART_PORT,
+  CURLUPART_PATH,
+  CURLUPART_QUERY,
+  CURLUPART_FRAGMENT,
+  CURLUPART_ZONEID /* added in 7.65.0 */
+} CURLUPart;
+
+#define CURLU_DEFAULT_PORT (1<<0)       /* return default port number */
+#define CURLU_NO_DEFAULT_PORT (1<<1)    /* act as if no port number was set,
+                                           if the port number matches the
+                                           default for the scheme */
+#define CURLU_DEFAULT_SCHEME (1<<2)     /* return default scheme if
+                                           missing */
+#define CURLU_NON_SUPPORT_SCHEME (1<<3) /* allow non-supported scheme */
+#define CURLU_PATH_AS_IS (1<<4)         /* leave dot sequences */
+#define CURLU_DISALLOW_USER (1<<5)      /* no user+password allowed */
+#define CURLU_URLDECODE (1<<6)          /* URL decode on get */
+#define CURLU_URLENCODE (1<<7)          /* URL encode on set */
+#define CURLU_APPENDQUERY (1<<8)        /* append a form style part */
+#define CURLU_GUESS_SCHEME (1<<9)       /* legacy curl-style guessing */
+#define CURLU_NO_AUTHORITY (1<<10)      /* Allow empty authority when the
+                                           scheme is unknown. */
+#define CURLU_ALLOW_SPACE (1<<11)       /* Allow spaces in the URL */
+
+typedef struct Curl_URL CURLU;
+
+/*
+ * curl_url() creates a new CURLU handle and returns a pointer to it.
+ * Must be freed with curl_url_cleanup().
+ */
+CURL_EXTERN CURLU *curl_url(void);
+
+/*
+ * curl_url_cleanup() frees the CURLU handle and related resources used for
+ * the URL parsing. It will not free strings previously returned with the URL
+ * API.
+ */
+CURL_EXTERN void curl_url_cleanup(CURLU *handle);
+
+/*
+ * curl_url_dup() duplicates a CURLU handle and returns a new copy. The new
+ * handle must also be freed with curl_url_cleanup().
+ */
+CURL_EXTERN CURLU *curl_url_dup(CURLU *in);
+
+/*
+ * curl_url_get() extracts a specific part of the URL from a CURLU
+ * handle. Returns error code. The returned pointer MUST be freed with
+ * curl_free() afterwards.
+ */
+CURL_EXTERN CURLUcode curl_url_get(CURLU *handle, CURLUPart what,
+                                   char **part, unsigned int flags);
+
+/*
+ * curl_url_set() sets a specific part of the URL in a CURLU handle. Returns
+ * error code. The passed in string will be copied. Passing a NULL instead of
+ * a part string, clears that part.
+ */
+CURL_EXTERN CURLUcode curl_url_set(CURLU *handle, CURLUPart what,
+                                   const char *part, unsigned int flags);
+
+/*
+ * curl_url_strerror() turns a CURLUcode value into the equivalent human
+ * readable error string.  This is useful for printing meaningful error
+ * messages.
+ */
+CURL_EXTERN const char *curl_url_strerror(CURLUcode);
+
+#ifdef __cplusplus
+} /* end of extern "C" */
+#endif
+
+#endif /* CURLINC_URLAPI_H */

EscapeTheBackroomsGUiTest/vcpkg_Out/include/curl/websockets.h

@@ -0,0 +1,83 @@
+#ifndef CURLINC_WEBSOCKETS_H
+#define CURLINC_WEBSOCKETS_H
+/***************************************************************************
+ *                                  _   _ ____  _
+ *  Project                     ___| | | |  _ \| |
+ *                             / __| | | | |_) | |
+ *                            | (__| |_| |  _ <| |___
+ *                             \___|\___/|_| \_\_____|
+ *
+ * Copyright (C) 1998 - 2022, Daniel Stenberg, <daniel@haxx.se>, et al.
+ *
+ * This software is licensed as described in the file COPYING, which
+ * you should have received as part of this distribution. The terms
+ * are also available at https://curl.se/docs/copyright.html.
+ *
+ * You may opt to use, copy, modify, merge, publish, distribute and/or sell
+ * copies of the Software, and permit persons to whom the Software is
+ * furnished to do so, under the terms of the COPYING file.
+ *
+ * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
+ * KIND, either express or implied.
+ *
+ * SPDX-License-Identifier: curl
+ *
+ ***************************************************************************/
+
+#ifdef  __cplusplus
+extern "C" {
+#endif
+
+struct curl_ws_frame {
+  int age;              /* zero */
+  int flags;            /* See the CURLWS_* defines */
+  curl_off_t offset;    /* the offset of this data into the frame */
+  curl_off_t bytesleft; /* number of pending bytes left of the payload */
+};
+
+/* flag bits */
+#define CURLWS_TEXT       (1<<0)
+#define CURLWS_BINARY     (1<<1)
+#define CURLWS_CONT       (1<<2)
+#define CURLWS_CLOSE      (1<<3)
+#define CURLWS_PING       (1<<4)
+#define CURLWS_OFFSET     (1<<5)
+
+/*
+ * NAME curl_ws_recv()
+ *
+ * DESCRIPTION
+ *
+ * Receives data from the websocket connection. Use after successful
+ * curl_easy_perform() with CURLOPT_CONNECT_ONLY option.
+ */
+CURL_EXTERN CURLcode curl_ws_recv(CURL *curl, void *buffer, size_t buflen,
+                                  size_t *recv,
+                                  struct curl_ws_frame **metap);
+
+/* sendflags for curl_ws_send() */
+#define CURLWS_PONG       (1<<6)
+
+/*
+ * NAME curl_easy_send()
+ *
+ * DESCRIPTION
+ *
+ * Sends data over the websocket connection. Use after successful
+ * curl_easy_perform() with CURLOPT_CONNECT_ONLY option.
+ */
+CURL_EXTERN CURLcode curl_ws_send(CURL *curl, const void *buffer,
+                                  size_t buflen, size_t *sent,
+                                  curl_off_t framesize,
+                                  unsigned int sendflags);
+
+/* bits for the CURLOPT_WS_OPTIONS bitmask: */
+#define CURLWS_RAW_MODE (1<<0)
+
+CURL_EXTERN struct curl_ws_frame *curl_ws_meta(CURL *curl);
+
+#ifdef  __cplusplus
+}
+#endif
+
+#endif /* CURLINC_WEBSOCKETS_H */

EscapeTheBackroomsGUiTest/vcpkg_Out/include/directx/d3d12compatibility.h

@@ -0,0 +1,739 @@
+/*-------------------------------------------------------------------------------------
+ *
+ * Copyright (c) Microsoft Corporation
+ * Licensed under the MIT license
+ *
+ *-------------------------------------------------------------------------------------*/
+
+
+/* this ALWAYS GENERATED file contains the definitions for the interfaces */
+
+
+ /* File created by MIDL compiler version 8.01.0628 */
+
+
+
+/* verify that the <rpcndr.h> version is high enough to compile this file*/
+#ifndef __REQUIRED_RPCNDR_H_VERSION__
+#define __REQUIRED_RPCNDR_H_VERSION__ 500
+#endif
+
+/* verify that the <rpcsal.h> version is high enough to compile this file*/
+#ifndef __REQUIRED_RPCSAL_H_VERSION__
+#define __REQUIRED_RPCSAL_H_VERSION__ 100
+#endif
+
+#include "rpc.h"
+#include "rpcndr.h"
+
+#ifndef __RPCNDR_H_VERSION__
+#error this stub requires an updated version of <rpcndr.h>
+#endif /* __RPCNDR_H_VERSION__ */
+
+#ifndef COM_NO_WINDOWS_H
+#include "windows.h"
+#include "ole2.h"
+#endif /*COM_NO_WINDOWS_H*/
+
+#ifndef __d3d12compatibility_h__
+#define __d3d12compatibility_h__
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+#pragma once
+#endif
+
+#ifndef DECLSPEC_XFGVIRT
+#if defined(_CONTROL_FLOW_GUARD_XFG)
+#define DECLSPEC_XFGVIRT(base, func) __declspec(xfg_virtual(base, func))
+#else
+#define DECLSPEC_XFGVIRT(base, func)
+#endif
+#endif
+
+/* Forward Declarations */ 
+
+#ifndef __ID3D12CompatibilityDevice_FWD_DEFINED__
+#define __ID3D12CompatibilityDevice_FWD_DEFINED__
+typedef interface ID3D12CompatibilityDevice ID3D12CompatibilityDevice;
+
+#endif 	/* __ID3D12CompatibilityDevice_FWD_DEFINED__ */
+
+
+#ifndef __D3D11On12CreatorID_FWD_DEFINED__
+#define __D3D11On12CreatorID_FWD_DEFINED__
+typedef interface D3D11On12CreatorID D3D11On12CreatorID;
+
+#endif 	/* __D3D11On12CreatorID_FWD_DEFINED__ */
+
+
+#ifndef __D3D9On12CreatorID_FWD_DEFINED__
+#define __D3D9On12CreatorID_FWD_DEFINED__
+typedef interface D3D9On12CreatorID D3D9On12CreatorID;
+
+#endif 	/* __D3D9On12CreatorID_FWD_DEFINED__ */
+
+
+#ifndef __OpenGLOn12CreatorID_FWD_DEFINED__
+#define __OpenGLOn12CreatorID_FWD_DEFINED__
+typedef interface OpenGLOn12CreatorID OpenGLOn12CreatorID;
+
+#endif 	/* __OpenGLOn12CreatorID_FWD_DEFINED__ */
+
+
+#ifndef __OpenCLOn12CreatorID_FWD_DEFINED__
+#define __OpenCLOn12CreatorID_FWD_DEFINED__
+typedef interface OpenCLOn12CreatorID OpenCLOn12CreatorID;
+
+#endif 	/* __OpenCLOn12CreatorID_FWD_DEFINED__ */
+
+
+#ifndef __DirectMLTensorFlowCreatorID_FWD_DEFINED__
+#define __DirectMLTensorFlowCreatorID_FWD_DEFINED__
+typedef interface DirectMLTensorFlowCreatorID DirectMLTensorFlowCreatorID;
+
+#endif 	/* __DirectMLTensorFlowCreatorID_FWD_DEFINED__ */
+
+
+#ifndef __DirectMLPyTorchCreatorID_FWD_DEFINED__
+#define __DirectMLPyTorchCreatorID_FWD_DEFINED__
+typedef interface DirectMLPyTorchCreatorID DirectMLPyTorchCreatorID;
+
+#endif 	/* __DirectMLPyTorchCreatorID_FWD_DEFINED__ */
+
+
+/* header files for imported files */
+#include "oaidl.h"
+#include "ocidl.h"
+#include "d3d11on12.h"
+
+#ifdef __cplusplus
+extern "C"{
+#endif 
+
+
+/* interface __MIDL_itf_d3d12compatibility_0000_0000 */
+/* [local] */ 
+
+#include <winapifamily.h>
+#pragma region Desktop Family
+#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP | WINAPI_PARTITION_GAMES)
+typedef 
+enum D3D12_COMPATIBILITY_SHARED_FLAGS
+    {
+        D3D12_COMPATIBILITY_SHARED_FLAG_NONE	= 0,
+        D3D12_COMPATIBILITY_SHARED_FLAG_NON_NT_HANDLE	= 0x1,
+        D3D12_COMPATIBILITY_SHARED_FLAG_KEYED_MUTEX	= 0x2,
+        D3D12_COMPATIBILITY_SHARED_FLAG_9_ON_12	= 0x4
+    } 	D3D12_COMPATIBILITY_SHARED_FLAGS;
+
+DEFINE_ENUM_FLAG_OPERATORS( D3D12_COMPATIBILITY_SHARED_FLAGS );
+typedef 
+enum D3D12_REFLECT_SHARED_PROPERTY
+    {
+        D3D12_REFLECT_SHARED_PROPERTY_D3D11_RESOURCE_FLAGS	= 0,
+        D3D12_REFELCT_SHARED_PROPERTY_COMPATIBILITY_SHARED_FLAGS	= ( D3D12_REFLECT_SHARED_PROPERTY_D3D11_RESOURCE_FLAGS + 1 ) ,
+        D3D12_REFLECT_SHARED_PROPERTY_NON_NT_SHARED_HANDLE	= ( D3D12_REFELCT_SHARED_PROPERTY_COMPATIBILITY_SHARED_FLAGS + 1 ) 
+    } 	D3D12_REFLECT_SHARED_PROPERTY;
+
+
+
+extern RPC_IF_HANDLE __MIDL_itf_d3d12compatibility_0000_0000_v0_0_c_ifspec;
+extern RPC_IF_HANDLE __MIDL_itf_d3d12compatibility_0000_0000_v0_0_s_ifspec;
+
+#ifndef __ID3D12CompatibilityDevice_INTERFACE_DEFINED__
+#define __ID3D12CompatibilityDevice_INTERFACE_DEFINED__
+
+/* interface ID3D12CompatibilityDevice */
+/* [unique][local][object][uuid] */ 
+
+
+EXTERN_C const IID IID_ID3D12CompatibilityDevice;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("8f1c0e3c-fae3-4a82-b098-bfe1708207ff")
+    ID3D12CompatibilityDevice : public IUnknown
+    {
+    public:
+        virtual HRESULT STDMETHODCALLTYPE CreateSharedResource( 
+            _In_  const D3D12_HEAP_PROPERTIES *pHeapProperties,
+            D3D12_HEAP_FLAGS HeapFlags,
+            _In_  const D3D12_RESOURCE_DESC *pDesc,
+            D3D12_RESOURCE_STATES InitialResourceState,
+            _In_opt_  const D3D12_CLEAR_VALUE *pOptimizedClearValue,
+            _In_opt_  const D3D11_RESOURCE_FLAGS *pFlags11,
+            D3D12_COMPATIBILITY_SHARED_FLAGS CompatibilityFlags,
+            _In_opt_  ID3D12LifetimeTracker *pLifetimeTracker,
+            _In_opt_  ID3D12SwapChainAssistant *pOwningSwapchain,
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppResource) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE CreateSharedHeap( 
+            _In_  const D3D12_HEAP_DESC *pHeapDesc,
+            D3D12_COMPATIBILITY_SHARED_FLAGS CompatibilityFlags,
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppHeap) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE ReflectSharedProperties( 
+            _In_  ID3D12Object *pHeapOrResource,
+            D3D12_REFLECT_SHARED_PROPERTY ReflectType,
+            _Out_writes_bytes_(DataSize)  void *pData,
+            UINT DataSize) = 0;
+        
+    };
+    
+    
+#else 	/* C style interface */
+
+    typedef struct ID3D12CompatibilityDeviceVtbl
+    {
+        BEGIN_INTERFACE
+        
+        DECLSPEC_XFGVIRT(IUnknown, QueryInterface)
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            ID3D12CompatibilityDevice * This,
+            REFIID riid,
+            _COM_Outptr_  void **ppvObject);
+        
+        DECLSPEC_XFGVIRT(IUnknown, AddRef)
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            ID3D12CompatibilityDevice * This);
+        
+        DECLSPEC_XFGVIRT(IUnknown, Release)
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            ID3D12CompatibilityDevice * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12CompatibilityDevice, CreateSharedResource)
+        HRESULT ( STDMETHODCALLTYPE *CreateSharedResource )( 
+            ID3D12CompatibilityDevice * This,
+            _In_  const D3D12_HEAP_PROPERTIES *pHeapProperties,
+            D3D12_HEAP_FLAGS HeapFlags,
+            _In_  const D3D12_RESOURCE_DESC *pDesc,
+            D3D12_RESOURCE_STATES InitialResourceState,
+            _In_opt_  const D3D12_CLEAR_VALUE *pOptimizedClearValue,
+            _In_opt_  const D3D11_RESOURCE_FLAGS *pFlags11,
+            D3D12_COMPATIBILITY_SHARED_FLAGS CompatibilityFlags,
+            _In_opt_  ID3D12LifetimeTracker *pLifetimeTracker,
+            _In_opt_  ID3D12SwapChainAssistant *pOwningSwapchain,
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppResource);
+        
+        DECLSPEC_XFGVIRT(ID3D12CompatibilityDevice, CreateSharedHeap)
+        HRESULT ( STDMETHODCALLTYPE *CreateSharedHeap )( 
+            ID3D12CompatibilityDevice * This,
+            _In_  const D3D12_HEAP_DESC *pHeapDesc,
+            D3D12_COMPATIBILITY_SHARED_FLAGS CompatibilityFlags,
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppHeap);
+        
+        DECLSPEC_XFGVIRT(ID3D12CompatibilityDevice, ReflectSharedProperties)
+        HRESULT ( STDMETHODCALLTYPE *ReflectSharedProperties )( 
+            ID3D12CompatibilityDevice * This,
+            _In_  ID3D12Object *pHeapOrResource,
+            D3D12_REFLECT_SHARED_PROPERTY ReflectType,
+            _Out_writes_bytes_(DataSize)  void *pData,
+            UINT DataSize);
+        
+        END_INTERFACE
+    } ID3D12CompatibilityDeviceVtbl;
+
+    interface ID3D12CompatibilityDevice
+    {
+        CONST_VTBL struct ID3D12CompatibilityDeviceVtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define ID3D12CompatibilityDevice_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define ID3D12CompatibilityDevice_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define ID3D12CompatibilityDevice_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define ID3D12CompatibilityDevice_CreateSharedResource(This,pHeapProperties,HeapFlags,pDesc,InitialResourceState,pOptimizedClearValue,pFlags11,CompatibilityFlags,pLifetimeTracker,pOwningSwapchain,riid,ppResource)	\
+    ( (This)->lpVtbl -> CreateSharedResource(This,pHeapProperties,HeapFlags,pDesc,InitialResourceState,pOptimizedClearValue,pFlags11,CompatibilityFlags,pLifetimeTracker,pOwningSwapchain,riid,ppResource) ) 
+
+#define ID3D12CompatibilityDevice_CreateSharedHeap(This,pHeapDesc,CompatibilityFlags,riid,ppHeap)	\
+    ( (This)->lpVtbl -> CreateSharedHeap(This,pHeapDesc,CompatibilityFlags,riid,ppHeap) ) 
+
+#define ID3D12CompatibilityDevice_ReflectSharedProperties(This,pHeapOrResource,ReflectType,pData,DataSize)	\
+    ( (This)->lpVtbl -> ReflectSharedProperties(This,pHeapOrResource,ReflectType,pData,DataSize) ) 
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __ID3D12CompatibilityDevice_INTERFACE_DEFINED__ */
+
+
+#ifndef __D3D11On12CreatorID_INTERFACE_DEFINED__
+#define __D3D11On12CreatorID_INTERFACE_DEFINED__
+
+/* interface D3D11On12CreatorID */
+/* [unique][local][object][uuid] */ 
+
+
+EXTERN_C const IID IID_D3D11On12CreatorID;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("edbf5678-2960-4e81-8429-99d4b2630c4e")
+    D3D11On12CreatorID : public IUnknown
+    {
+    public:
+    };
+    
+    
+#else 	/* C style interface */
+
+    typedef struct D3D11On12CreatorIDVtbl
+    {
+        BEGIN_INTERFACE
+        
+        DECLSPEC_XFGVIRT(IUnknown, QueryInterface)
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            D3D11On12CreatorID * This,
+            REFIID riid,
+            _COM_Outptr_  void **ppvObject);
+        
+        DECLSPEC_XFGVIRT(IUnknown, AddRef)
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            D3D11On12CreatorID * This);
+        
+        DECLSPEC_XFGVIRT(IUnknown, Release)
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            D3D11On12CreatorID * This);
+        
+        END_INTERFACE
+    } D3D11On12CreatorIDVtbl;
+
+    interface D3D11On12CreatorID
+    {
+        CONST_VTBL struct D3D11On12CreatorIDVtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define D3D11On12CreatorID_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define D3D11On12CreatorID_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define D3D11On12CreatorID_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __D3D11On12CreatorID_INTERFACE_DEFINED__ */
+
+
+#ifndef __D3D9On12CreatorID_INTERFACE_DEFINED__
+#define __D3D9On12CreatorID_INTERFACE_DEFINED__
+
+/* interface D3D9On12CreatorID */
+/* [unique][local][object][uuid] */ 
+
+
+EXTERN_C const IID IID_D3D9On12CreatorID;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("fffcbb7f-15d3-42a2-841e-9d8d32f37ddd")
+    D3D9On12CreatorID : public IUnknown
+    {
+    public:
+    };
+    
+    
+#else 	/* C style interface */
+
+    typedef struct D3D9On12CreatorIDVtbl
+    {
+        BEGIN_INTERFACE
+        
+        DECLSPEC_XFGVIRT(IUnknown, QueryInterface)
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            D3D9On12CreatorID * This,
+            REFIID riid,
+            _COM_Outptr_  void **ppvObject);
+        
+        DECLSPEC_XFGVIRT(IUnknown, AddRef)
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            D3D9On12CreatorID * This);
+        
+        DECLSPEC_XFGVIRT(IUnknown, Release)
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            D3D9On12CreatorID * This);
+        
+        END_INTERFACE
+    } D3D9On12CreatorIDVtbl;
+
+    interface D3D9On12CreatorID
+    {
+        CONST_VTBL struct D3D9On12CreatorIDVtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define D3D9On12CreatorID_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define D3D9On12CreatorID_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define D3D9On12CreatorID_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __D3D9On12CreatorID_INTERFACE_DEFINED__ */
+
+
+#ifndef __OpenGLOn12CreatorID_INTERFACE_DEFINED__
+#define __OpenGLOn12CreatorID_INTERFACE_DEFINED__
+
+/* interface OpenGLOn12CreatorID */
+/* [unique][local][object][uuid] */ 
+
+
+EXTERN_C const IID IID_OpenGLOn12CreatorID;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("6bb3cd34-0d19-45ab-97ed-d720ba3dfc80")
+    OpenGLOn12CreatorID : public IUnknown
+    {
+    public:
+    };
+    
+    
+#else 	/* C style interface */
+
+    typedef struct OpenGLOn12CreatorIDVtbl
+    {
+        BEGIN_INTERFACE
+        
+        DECLSPEC_XFGVIRT(IUnknown, QueryInterface)
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            OpenGLOn12CreatorID * This,
+            REFIID riid,
+            _COM_Outptr_  void **ppvObject);
+        
+        DECLSPEC_XFGVIRT(IUnknown, AddRef)
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            OpenGLOn12CreatorID * This);
+        
+        DECLSPEC_XFGVIRT(IUnknown, Release)
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            OpenGLOn12CreatorID * This);
+        
+        END_INTERFACE
+    } OpenGLOn12CreatorIDVtbl;
+
+    interface OpenGLOn12CreatorID
+    {
+        CONST_VTBL struct OpenGLOn12CreatorIDVtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define OpenGLOn12CreatorID_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define OpenGLOn12CreatorID_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define OpenGLOn12CreatorID_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __OpenGLOn12CreatorID_INTERFACE_DEFINED__ */
+
+
+#ifndef __OpenCLOn12CreatorID_INTERFACE_DEFINED__
+#define __OpenCLOn12CreatorID_INTERFACE_DEFINED__
+
+/* interface OpenCLOn12CreatorID */
+/* [unique][local][object][uuid] */ 
+
+
+EXTERN_C const IID IID_OpenCLOn12CreatorID;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("3f76bb74-91b5-4a88-b126-20ca0331cd60")
+    OpenCLOn12CreatorID : public IUnknown
+    {
+    public:
+    };
+    
+    
+#else 	/* C style interface */
+
+    typedef struct OpenCLOn12CreatorIDVtbl
+    {
+        BEGIN_INTERFACE
+        
+        DECLSPEC_XFGVIRT(IUnknown, QueryInterface)
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            OpenCLOn12CreatorID * This,
+            REFIID riid,
+            _COM_Outptr_  void **ppvObject);
+        
+        DECLSPEC_XFGVIRT(IUnknown, AddRef)
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            OpenCLOn12CreatorID * This);
+        
+        DECLSPEC_XFGVIRT(IUnknown, Release)
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            OpenCLOn12CreatorID * This);
+        
+        END_INTERFACE
+    } OpenCLOn12CreatorIDVtbl;
+
+    interface OpenCLOn12CreatorID
+    {
+        CONST_VTBL struct OpenCLOn12CreatorIDVtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define OpenCLOn12CreatorID_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define OpenCLOn12CreatorID_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define OpenCLOn12CreatorID_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __OpenCLOn12CreatorID_INTERFACE_DEFINED__ */
+
+
+#ifndef __DirectMLTensorFlowCreatorID_INTERFACE_DEFINED__
+#define __DirectMLTensorFlowCreatorID_INTERFACE_DEFINED__
+
+/* interface DirectMLTensorFlowCreatorID */
+/* [unique][local][object][uuid] */ 
+
+
+EXTERN_C const IID IID_DirectMLTensorFlowCreatorID;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("cb7490ac-8a0f-44ec-9b7b-6f4cafe8e9ab")
+    DirectMLTensorFlowCreatorID : public IUnknown
+    {
+    public:
+    };
+    
+    
+#else 	/* C style interface */
+
+    typedef struct DirectMLTensorFlowCreatorIDVtbl
+    {
+        BEGIN_INTERFACE
+        
+        DECLSPEC_XFGVIRT(IUnknown, QueryInterface)
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            DirectMLTensorFlowCreatorID * This,
+            REFIID riid,
+            _COM_Outptr_  void **ppvObject);
+        
+        DECLSPEC_XFGVIRT(IUnknown, AddRef)
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            DirectMLTensorFlowCreatorID * This);
+        
+        DECLSPEC_XFGVIRT(IUnknown, Release)
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            DirectMLTensorFlowCreatorID * This);
+        
+        END_INTERFACE
+    } DirectMLTensorFlowCreatorIDVtbl;
+
+    interface DirectMLTensorFlowCreatorID
+    {
+        CONST_VTBL struct DirectMLTensorFlowCreatorIDVtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define DirectMLTensorFlowCreatorID_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define DirectMLTensorFlowCreatorID_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define DirectMLTensorFlowCreatorID_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __DirectMLTensorFlowCreatorID_INTERFACE_DEFINED__ */
+
+
+#ifndef __DirectMLPyTorchCreatorID_INTERFACE_DEFINED__
+#define __DirectMLPyTorchCreatorID_INTERFACE_DEFINED__
+
+/* interface DirectMLPyTorchCreatorID */
+/* [unique][local][object][uuid] */ 
+
+
+EXTERN_C const IID IID_DirectMLPyTorchCreatorID;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("af029192-fba1-4b05-9116-235e06560354")
+    DirectMLPyTorchCreatorID : public IUnknown
+    {
+    public:
+    };
+    
+    
+#else 	/* C style interface */
+
+    typedef struct DirectMLPyTorchCreatorIDVtbl
+    {
+        BEGIN_INTERFACE
+        
+        DECLSPEC_XFGVIRT(IUnknown, QueryInterface)
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            DirectMLPyTorchCreatorID * This,
+            REFIID riid,
+            _COM_Outptr_  void **ppvObject);
+        
+        DECLSPEC_XFGVIRT(IUnknown, AddRef)
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            DirectMLPyTorchCreatorID * This);
+        
+        DECLSPEC_XFGVIRT(IUnknown, Release)
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            DirectMLPyTorchCreatorID * This);
+        
+        END_INTERFACE
+    } DirectMLPyTorchCreatorIDVtbl;
+
+    interface DirectMLPyTorchCreatorID
+    {
+        CONST_VTBL struct DirectMLPyTorchCreatorIDVtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define DirectMLPyTorchCreatorID_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define DirectMLPyTorchCreatorID_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define DirectMLPyTorchCreatorID_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __DirectMLPyTorchCreatorID_INTERFACE_DEFINED__ */
+
+
+/* interface __MIDL_itf_d3d12compatibility_0000_0007 */
+/* [local] */ 
+
+#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP | WINAPI_PARTITION_GAMES) */
+#pragma endregion
+DEFINE_GUID(IID_ID3D12CompatibilityDevice,0x8f1c0e3c,0xfae3,0x4a82,0xb0,0x98,0xbf,0xe1,0x70,0x82,0x07,0xff);
+DEFINE_GUID(IID_D3D11On12CreatorID,0xedbf5678,0x2960,0x4e81,0x84,0x29,0x99,0xd4,0xb2,0x63,0x0c,0x4e);
+DEFINE_GUID(IID_D3D9On12CreatorID,0xfffcbb7f,0x15d3,0x42a2,0x84,0x1e,0x9d,0x8d,0x32,0xf3,0x7d,0xdd);
+DEFINE_GUID(IID_OpenGLOn12CreatorID,0x6bb3cd34,0x0d19,0x45ab,0x97,0xed,0xd7,0x20,0xba,0x3d,0xfc,0x80);
+DEFINE_GUID(IID_OpenCLOn12CreatorID,0x3f76bb74,0x91b5,0x4a88,0xb1,0x26,0x20,0xca,0x03,0x31,0xcd,0x60);
+DEFINE_GUID(IID_DirectMLTensorFlowCreatorID,0xcb7490ac,0x8a0f,0x44ec,0x9b,0x7b,0x6f,0x4c,0xaf,0xe8,0xe9,0xab);
+DEFINE_GUID(IID_DirectMLPyTorchCreatorID,0xaf029192,0xfba1,0x4b05,0x91,0x16,0x23,0x5e,0x06,0x56,0x03,0x54);
+
+
+extern RPC_IF_HANDLE __MIDL_itf_d3d12compatibility_0000_0007_v0_0_c_ifspec;
+extern RPC_IF_HANDLE __MIDL_itf_d3d12compatibility_0000_0007_v0_0_s_ifspec;
+
+/* Additional Prototypes for ALL interfaces */
+
+/* end of Additional Prototypes */
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+
+

EscapeTheBackroomsGUiTest/vcpkg_Out/include/directx/d3d12compatibility.idl

@@ -0,0 +1,92 @@
+/*-------------------------------------------------------------------------------------
+ *
+ * Copyright (c) Microsoft Corporation
+ * Licensed under the MIT license
+ *
+ *-------------------------------------------------------------------------------------*/
+import "oaidl.idl";
+import "ocidl.idl";
+
+import "d3d11on12.idl";
+
+cpp_quote("#include <winapifamily.h>")
+
+#pragma region Desktop Family
+cpp_quote("#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP | WINAPI_PARTITION_GAMES)")
+
+typedef enum D3D12_COMPATIBILITY_SHARED_FLAGS
+{
+    D3D12_COMPATIBILITY_SHARED_FLAG_NONE          = 0,
+    D3D12_COMPATIBILITY_SHARED_FLAG_NON_NT_HANDLE = 0x1,
+    D3D12_COMPATIBILITY_SHARED_FLAG_KEYED_MUTEX = 0x2,
+    D3D12_COMPATIBILITY_SHARED_FLAG_9_ON_12 = 0x4,
+
+} D3D12_COMPATIBILITY_SHARED_FLAGS;
+cpp_quote( "DEFINE_ENUM_FLAG_OPERATORS( D3D12_COMPATIBILITY_SHARED_FLAGS );" )
+
+typedef enum D3D12_REFLECT_SHARED_PROPERTY
+{
+    D3D12_REFLECT_SHARED_PROPERTY_D3D11_RESOURCE_FLAGS,       // D3D11_RESOURCE_FLAGS
+    D3D12_REFELCT_SHARED_PROPERTY_COMPATIBILITY_SHARED_FLAGS, // D3D12_COMPATIBILITY_SHARED_FLAGS
+    D3D12_REFLECT_SHARED_PROPERTY_NON_NT_SHARED_HANDLE,       // HANDLE
+} D3D12_REFLECT_SHARED_PROPERTY;
+
+[ uuid( 8f1c0e3c-fae3-4a82-b098-bfe1708207ff ), object, local, pointer_default( unique ) ]
+interface ID3D12CompatibilityDevice
+    : IUnknown
+{
+    HRESULT CreateSharedResource(
+        [annotation("_In_")] const D3D12_HEAP_PROPERTIES* pHeapProperties,
+        D3D12_HEAP_FLAGS HeapFlags,
+        [annotation("_In_")] const D3D12_RESOURCE_DESC* pDesc,
+        D3D12_RESOURCE_STATES InitialResourceState,
+        [annotation("_In_opt_")] const D3D12_CLEAR_VALUE* pOptimizedClearValue,
+        [annotation("_In_opt_")] const D3D11_RESOURCE_FLAGS* pFlags11,
+        D3D12_COMPATIBILITY_SHARED_FLAGS CompatibilityFlags,
+        [annotation("_In_opt_")] ID3D12LifetimeTracker* pLifetimeTracker,
+        [annotation("_In_opt_")] ID3D12SwapChainAssistant* pOwningSwapchain,
+        REFIID riid,
+        [out, iid_is(riid), annotation("_COM_Outptr_opt_")] void** ppResource);
+
+    HRESULT CreateSharedHeap(
+        [annotation("_In_")] const D3D12_HEAP_DESC* pHeapDesc,
+        D3D12_COMPATIBILITY_SHARED_FLAGS CompatibilityFlags,
+        REFIID riid,
+        [out, iid_is(riid), annotation("_COM_Outptr_opt_")] void** ppHeap);
+
+    HRESULT ReflectSharedProperties(
+        [annotation("_In_")] ID3D12Object* pHeapOrResource,
+        D3D12_REFLECT_SHARED_PROPERTY ReflectType,
+        [annotation("_Out_writes_bytes_(DataSize)")] void* pData,
+        UINT DataSize);
+}
+
+[uuid(edbf5678-2960-4e81-8429-99d4b2630c4e), object, local, pointer_default(unique)]
+interface D3D11On12CreatorID : IUnknown { };
+
+[uuid(fffcbb7f-15d3-42a2-841e-9d8d32f37ddd), object, local, pointer_default(unique)]
+interface D3D9On12CreatorID : IUnknown { };
+
+[uuid(6bb3cd34-0d19-45ab-97ed-d720ba3dfc80), object, local, pointer_default(unique)]
+interface OpenGLOn12CreatorID : IUnknown { };
+
+[uuid(3f76bb74-91b5-4a88-b126-20ca0331cd60), object, local, pointer_default(unique)]
+interface OpenCLOn12CreatorID : IUnknown { };
+
+[uuid(cb7490ac-8a0f-44ec-9b7b-6f4cafe8e9ab), object, local, pointer_default(unique)]
+interface DirectMLTensorFlowCreatorID : IUnknown { };
+
+[uuid(af029192-fba1-4b05-9116-235e06560354), object, local, pointer_default(unique)]
+interface DirectMLPyTorchCreatorID : IUnknown { };
+
+
+cpp_quote("#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP | WINAPI_PARTITION_GAMES) */")
+#pragma endregion
+
+cpp_quote( "DEFINE_GUID(IID_ID3D12CompatibilityDevice,0x8f1c0e3c,0xfae3,0x4a82,0xb0,0x98,0xbf,0xe1,0x70,0x82,0x07,0xff);" )
+cpp_quote( "DEFINE_GUID(IID_D3D11On12CreatorID,0xedbf5678,0x2960,0x4e81,0x84,0x29,0x99,0xd4,0xb2,0x63,0x0c,0x4e);" )
+cpp_quote( "DEFINE_GUID(IID_D3D9On12CreatorID,0xfffcbb7f,0x15d3,0x42a2,0x84,0x1e,0x9d,0x8d,0x32,0xf3,0x7d,0xdd);" )
+cpp_quote( "DEFINE_GUID(IID_OpenGLOn12CreatorID,0x6bb3cd34,0x0d19,0x45ab,0x97,0xed,0xd7,0x20,0xba,0x3d,0xfc,0x80);" )
+cpp_quote( "DEFINE_GUID(IID_OpenCLOn12CreatorID,0x3f76bb74,0x91b5,0x4a88,0xb1,0x26,0x20,0xca,0x03,0x31,0xcd,0x60);" )
+cpp_quote( "DEFINE_GUID(IID_DirectMLTensorFlowCreatorID,0xcb7490ac,0x8a0f,0x44ec,0x9b,0x7b,0x6f,0x4c,0xaf,0xe8,0xe9,0xab);" )
+cpp_quote( "DEFINE_GUID(IID_DirectMLPyTorchCreatorID,0xaf029192,0xfba1,0x4b05,0x91,0x16,0x23,0x5e,0x06,0x56,0x03,0x54);" )

EscapeTheBackroomsGUiTest/vcpkg_Out/include/directx/d3d12shader.h

@@ -0,0 +1,490 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+//  Copyright (c) Microsoft Corporation.
+//  Licensed under the MIT license.
+//
+//  File:       D3D12Shader.h
+//  Content:    D3D12 Shader Types and APIs
+//
+//////////////////////////////////////////////////////////////////////////////
+
+#ifndef __D3D12SHADER_H__
+#define __D3D12SHADER_H__
+
+#include "d3dcommon.h"
+
+typedef enum D3D12_SHADER_VERSION_TYPE
+{
+    D3D12_SHVER_PIXEL_SHADER          = 0,
+    D3D12_SHVER_VERTEX_SHADER         = 1,
+    D3D12_SHVER_GEOMETRY_SHADER       = 2,
+    
+    // D3D11 Shaders
+    D3D12_SHVER_HULL_SHADER           = 3,
+    D3D12_SHVER_DOMAIN_SHADER         = 4,
+    D3D12_SHVER_COMPUTE_SHADER        = 5,
+
+    // D3D12 Shaders
+    D3D12_SHVER_LIBRARY               = 6,
+
+    D3D12_SHVER_RAY_GENERATION_SHADER = 7,
+    D3D12_SHVER_INTERSECTION_SHADER   = 8,
+    D3D12_SHVER_ANY_HIT_SHADER        = 9,
+    D3D12_SHVER_CLOSEST_HIT_SHADER    = 10,
+    D3D12_SHVER_MISS_SHADER           = 11,
+    D3D12_SHVER_CALLABLE_SHADER       = 12,
+
+    D3D12_SHVER_MESH_SHADER           = 13,
+    D3D12_SHVER_AMPLIFICATION_SHADER  = 14,
+
+    D3D12_SHVER_RESERVED0             = 0xFFF0,
+} D3D12_SHADER_VERSION_TYPE;
+
+#define D3D12_SHVER_GET_TYPE(_Version) \
+    (((_Version) >> 16) & 0xffff)
+#define D3D12_SHVER_GET_MAJOR(_Version) \
+    (((_Version) >> 4) & 0xf)
+#define D3D12_SHVER_GET_MINOR(_Version) \
+    (((_Version) >> 0) & 0xf)
+
+// Slot ID for library function return
+#define D3D_RETURN_PARAMETER_INDEX (-1)
+
+typedef D3D_RESOURCE_RETURN_TYPE D3D12_RESOURCE_RETURN_TYPE;
+
+typedef D3D_CBUFFER_TYPE D3D12_CBUFFER_TYPE;
+
+
+typedef struct _D3D12_SIGNATURE_PARAMETER_DESC
+{
+    LPCSTR                      SemanticName;   // Name of the semantic
+    UINT                        SemanticIndex;  // Index of the semantic
+    UINT                        Register;       // Number of member variables
+    D3D_NAME                    SystemValueType;// A predefined system value, or D3D_NAME_UNDEFINED if not applicable
+    D3D_REGISTER_COMPONENT_TYPE ComponentType;  // Scalar type (e.g. uint, float, etc.)
+    BYTE                        Mask;           // Mask to indicate which components of the register
+                                                // are used (combination of D3D10_COMPONENT_MASK values)
+    BYTE                        ReadWriteMask;  // Mask to indicate whether a given component is 
+                                                // never written (if this is an output signature) or
+                                                // always read (if this is an input signature).
+                                                // (combination of D3D_MASK_* values)
+    UINT                        Stream;         // Stream index
+    D3D_MIN_PRECISION           MinPrecision;   // Minimum desired interpolation precision
+} D3D12_SIGNATURE_PARAMETER_DESC;
+
+typedef struct _D3D12_SHADER_BUFFER_DESC
+{
+    LPCSTR                  Name;           // Name of the constant buffer
+    D3D_CBUFFER_TYPE        Type;           // Indicates type of buffer content
+    UINT                    Variables;      // Number of member variables
+    UINT                    Size;           // Size of CB (in bytes)
+    UINT                    uFlags;         // Buffer description flags
+} D3D12_SHADER_BUFFER_DESC;
+
+typedef struct _D3D12_SHADER_VARIABLE_DESC
+{
+    LPCSTR                  Name;           // Name of the variable
+    UINT                    StartOffset;    // Offset in constant buffer's backing store
+    UINT                    Size;           // Size of variable (in bytes)
+    UINT                    uFlags;         // Variable flags
+    LPVOID                  DefaultValue;   // Raw pointer to default value
+    UINT                    StartTexture;   // First texture index (or -1 if no textures used)
+    UINT                    TextureSize;    // Number of texture slots possibly used.
+    UINT                    StartSampler;   // First sampler index (or -1 if no textures used)
+    UINT                    SamplerSize;    // Number of sampler slots possibly used.
+} D3D12_SHADER_VARIABLE_DESC;
+
+typedef struct _D3D12_SHADER_TYPE_DESC
+{
+    D3D_SHADER_VARIABLE_CLASS   Class;          // Variable class (e.g. object, matrix, etc.)
+    D3D_SHADER_VARIABLE_TYPE    Type;           // Variable type (e.g. float, sampler, etc.)
+    UINT                        Rows;           // Number of rows (for matrices, 1 for other numeric, 0 if not applicable)
+    UINT                        Columns;        // Number of columns (for vectors & matrices, 1 for other numeric, 0 if not applicable)
+    UINT                        Elements;       // Number of elements (0 if not an array)
+    UINT                        Members;        // Number of members (0 if not a structure)
+    UINT                        Offset;         // Offset from the start of structure (0 if not a structure member)
+    LPCSTR                      Name;           // Name of type, can be NULL
+} D3D12_SHADER_TYPE_DESC;
+
+typedef D3D_TESSELLATOR_DOMAIN D3D12_TESSELLATOR_DOMAIN;
+
+typedef D3D_TESSELLATOR_PARTITIONING D3D12_TESSELLATOR_PARTITIONING;
+
+typedef D3D_TESSELLATOR_OUTPUT_PRIMITIVE D3D12_TESSELLATOR_OUTPUT_PRIMITIVE;
+
+typedef struct _D3D12_SHADER_DESC
+{
+    UINT                    Version;                     // Shader version
+    LPCSTR                  Creator;                     // Creator string
+    UINT                    Flags;                       // Shader compilation/parse flags
+    
+    UINT                    ConstantBuffers;             // Number of constant buffers
+    UINT                    BoundResources;              // Number of bound resources
+    UINT                    InputParameters;             // Number of parameters in the input signature
+    UINT                    OutputParameters;            // Number of parameters in the output signature
+
+    UINT                    InstructionCount;            // Number of emitted instructions
+    UINT                    TempRegisterCount;           // Number of temporary registers used 
+    UINT                    TempArrayCount;              // Number of temporary arrays used
+    UINT                    DefCount;                    // Number of constant defines 
+    UINT                    DclCount;                    // Number of declarations (input + output)
+    UINT                    TextureNormalInstructions;   // Number of non-categorized texture instructions
+    UINT                    TextureLoadInstructions;     // Number of texture load instructions
+    UINT                    TextureCompInstructions;     // Number of texture comparison instructions
+    UINT                    TextureBiasInstructions;     // Number of texture bias instructions
+    UINT                    TextureGradientInstructions; // Number of texture gradient instructions
+    UINT                    FloatInstructionCount;       // Number of floating point arithmetic instructions used
+    UINT                    IntInstructionCount;         // Number of signed integer arithmetic instructions used
+    UINT                    UintInstructionCount;        // Number of unsigned integer arithmetic instructions used
+    UINT                    StaticFlowControlCount;      // Number of static flow control instructions used
+    UINT                    DynamicFlowControlCount;     // Number of dynamic flow control instructions used
+    UINT                    MacroInstructionCount;       // Number of macro instructions used
+    UINT                    ArrayInstructionCount;       // Number of array instructions used
+    UINT                    CutInstructionCount;         // Number of cut instructions used
+    UINT                    EmitInstructionCount;        // Number of emit instructions used
+    D3D_PRIMITIVE_TOPOLOGY  GSOutputTopology;            // Geometry shader output topology
+    UINT                    GSMaxOutputVertexCount;      // Geometry shader maximum output vertex count
+    D3D_PRIMITIVE           InputPrimitive;              // GS/HS input primitive
+    UINT                    PatchConstantParameters;     // Number of parameters in the patch constant signature
+    UINT                    cGSInstanceCount;            // Number of Geometry shader instances
+    UINT                    cControlPoints;              // Number of control points in the HS->DS stage
+    D3D_TESSELLATOR_OUTPUT_PRIMITIVE HSOutputPrimitive;  // Primitive output by the tessellator
+    D3D_TESSELLATOR_PARTITIONING HSPartitioning;         // Partitioning mode of the tessellator
+    D3D_TESSELLATOR_DOMAIN  TessellatorDomain;           // Domain of the tessellator (quad, tri, isoline)
+    // instruction counts
+    UINT cBarrierInstructions;                           // Number of barrier instructions in a compute shader
+    UINT cInterlockedInstructions;                       // Number of interlocked instructions
+    UINT cTextureStoreInstructions;                      // Number of texture writes
+} D3D12_SHADER_DESC;
+
+typedef struct _D3D12_SHADER_INPUT_BIND_DESC
+{
+    LPCSTR                      Name;           // Name of the resource
+    D3D_SHADER_INPUT_TYPE       Type;           // Type of resource (e.g. texture, cbuffer, etc.)
+    UINT                        BindPoint;      // Starting bind point
+    UINT                        BindCount;      // Number of contiguous bind points (for arrays)
+
+    UINT                        uFlags;         // Input binding flags
+    D3D_RESOURCE_RETURN_TYPE    ReturnType;     // Return type (if texture)
+    D3D_SRV_DIMENSION           Dimension;      // Dimension (if texture)
+    UINT                        NumSamples;     // Number of samples (0 if not MS texture)
+    UINT                        Space;          // Register space
+    UINT uID;                                   // Range ID in the bytecode
+} D3D12_SHADER_INPUT_BIND_DESC;
+
+#define D3D_SHADER_REQUIRES_DOUBLES                                                         0x00000001
+#define D3D_SHADER_REQUIRES_EARLY_DEPTH_STENCIL                                             0x00000002
+#define D3D_SHADER_REQUIRES_UAVS_AT_EVERY_STAGE                                             0x00000004
+#define D3D_SHADER_REQUIRES_64_UAVS                                                         0x00000008
+#define D3D_SHADER_REQUIRES_MINIMUM_PRECISION                                               0x00000010
+#define D3D_SHADER_REQUIRES_11_1_DOUBLE_EXTENSIONS                                          0x00000020
+#define D3D_SHADER_REQUIRES_11_1_SHADER_EXTENSIONS                                          0x00000040
+#define D3D_SHADER_REQUIRES_LEVEL_9_COMPARISON_FILTERING                                    0x00000080
+#define D3D_SHADER_REQUIRES_TILED_RESOURCES                                                 0x00000100
+#define D3D_SHADER_REQUIRES_STENCIL_REF                                                     0x00000200
+#define D3D_SHADER_REQUIRES_INNER_COVERAGE                                                  0x00000400
+#define D3D_SHADER_REQUIRES_TYPED_UAV_LOAD_ADDITIONAL_FORMATS                               0x00000800
+#define D3D_SHADER_REQUIRES_ROVS                                                            0x00001000
+#define D3D_SHADER_REQUIRES_VIEWPORT_AND_RT_ARRAY_INDEX_FROM_ANY_SHADER_FEEDING_RASTERIZER  0x00002000
+#define D3D_SHADER_REQUIRES_WAVE_OPS                                                        0x00004000
+#define D3D_SHADER_REQUIRES_INT64_OPS                                                       0x00008000
+#define D3D_SHADER_REQUIRES_VIEW_ID                                                         0x00010000
+#define D3D_SHADER_REQUIRES_BARYCENTRICS                                                    0x00020000
+#define D3D_SHADER_REQUIRES_NATIVE_16BIT_OPS                                                0x00040000
+#define D3D_SHADER_REQUIRES_SHADING_RATE                                                    0x00080000
+#define D3D_SHADER_REQUIRES_RAYTRACING_TIER_1_1                                             0x00100000
+#define D3D_SHADER_REQUIRES_SAMPLER_FEEDBACK                                                0x00200000
+#define D3D_SHADER_REQUIRES_ATOMIC_INT64_ON_TYPED_RESOURCE                                  0x00400000
+#define D3D_SHADER_REQUIRES_ATOMIC_INT64_ON_GROUP_SHARED                                    0x00800000
+#define D3D_SHADER_REQUIRES_DERIVATIVES_IN_MESH_AND_AMPLIFICATION_SHADERS                   0x01000000
+#define D3D_SHADER_REQUIRES_RESOURCE_DESCRIPTOR_HEAP_INDEXING                               0x02000000
+#define D3D_SHADER_REQUIRES_SAMPLER_DESCRIPTOR_HEAP_INDEXING                                0x04000000
+#define D3D_SHADER_REQUIRES_WAVE_MMA                                                        0x08000000
+#define D3D_SHADER_REQUIRES_ATOMIC_INT64_ON_DESCRIPTOR_HEAP_RESOURCE                        0x10000000
+#define D3D_SHADER_FEATURE_ADVANCED_TEXTURE_OPS                                             0x20000000
+#define D3D_SHADER_FEATURE_WRITEABLE_MSAA_TEXTURES                                          0x40000000
+
+
+typedef struct _D3D12_LIBRARY_DESC
+{
+    LPCSTR    Creator;           // The name of the originator of the library.
+    UINT      Flags;             // Compilation flags.
+    UINT      FunctionCount;     // Number of functions exported from the library.
+} D3D12_LIBRARY_DESC;
+
+typedef struct _D3D12_FUNCTION_DESC
+{
+    UINT                    Version;                     // Shader version
+    LPCSTR                  Creator;                     // Creator string
+    UINT                    Flags;                       // Shader compilation/parse flags
+    
+    UINT                    ConstantBuffers;             // Number of constant buffers
+    UINT                    BoundResources;              // Number of bound resources
+
+    UINT                    InstructionCount;            // Number of emitted instructions
+    UINT                    TempRegisterCount;           // Number of temporary registers used 
+    UINT                    TempArrayCount;              // Number of temporary arrays used
+    UINT                    DefCount;                    // Number of constant defines 
+    UINT                    DclCount;                    // Number of declarations (input + output)
+    UINT                    TextureNormalInstructions;   // Number of non-categorized texture instructions
+    UINT                    TextureLoadInstructions;     // Number of texture load instructions
+    UINT                    TextureCompInstructions;     // Number of texture comparison instructions
+    UINT                    TextureBiasInstructions;     // Number of texture bias instructions
+    UINT                    TextureGradientInstructions; // Number of texture gradient instructions
+    UINT                    FloatInstructionCount;       // Number of floating point arithmetic instructions used
+    UINT                    IntInstructionCount;         // Number of signed integer arithmetic instructions used
+    UINT                    UintInstructionCount;        // Number of unsigned integer arithmetic instructions used
+    UINT                    StaticFlowControlCount;      // Number of static flow control instructions used
+    UINT                    DynamicFlowControlCount;     // Number of dynamic flow control instructions used
+    UINT                    MacroInstructionCount;       // Number of macro instructions used
+    UINT                    ArrayInstructionCount;       // Number of array instructions used
+    UINT                    MovInstructionCount;         // Number of mov instructions used
+    UINT                    MovcInstructionCount;        // Number of movc instructions used
+    UINT                    ConversionInstructionCount;  // Number of type conversion instructions used
+    UINT                    BitwiseInstructionCount;     // Number of bitwise arithmetic instructions used
+    D3D_FEATURE_LEVEL       MinFeatureLevel;             // Min target of the function byte code
+    UINT64                  RequiredFeatureFlags;        // Required feature flags
+
+    LPCSTR                  Name;                        // Function name
+    INT                     FunctionParameterCount;      // Number of logical parameters in the function signature (not including return)
+    BOOL                    HasReturn;                   // TRUE, if function returns a value, false - it is a subroutine
+    BOOL                    Has10Level9VertexShader;     // TRUE, if there is a 10L9 VS blob
+    BOOL                    Has10Level9PixelShader;      // TRUE, if there is a 10L9 PS blob
+} D3D12_FUNCTION_DESC;
+
+typedef struct _D3D12_PARAMETER_DESC
+{
+    LPCSTR                      Name;               // Parameter name.
+    LPCSTR                      SemanticName;       // Parameter semantic name (+index).
+    D3D_SHADER_VARIABLE_TYPE    Type;               // Element type.
+    D3D_SHADER_VARIABLE_CLASS   Class;              // Scalar/Vector/Matrix.
+    UINT                        Rows;               // Rows are for matrix parameters.
+    UINT                        Columns;            // Components or Columns in matrix.
+    D3D_INTERPOLATION_MODE      InterpolationMode;  // Interpolation mode.
+    D3D_PARAMETER_FLAGS         Flags;              // Parameter modifiers.
+
+    UINT                        FirstInRegister;    // The first input register for this parameter.
+    UINT                        FirstInComponent;   // The first input register component for this parameter.
+    UINT                        FirstOutRegister;   // The first output register for this parameter.
+    UINT                        FirstOutComponent;  // The first output register component for this parameter.
+} D3D12_PARAMETER_DESC;
+
+
+//////////////////////////////////////////////////////////////////////////////
+// Interfaces ////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////////
+
+typedef interface ID3D12ShaderReflectionType ID3D12ShaderReflectionType;
+typedef interface ID3D12ShaderReflectionType *LPD3D12SHADERREFLECTIONTYPE;
+
+typedef interface ID3D12ShaderReflectionVariable ID3D12ShaderReflectionVariable;
+typedef interface ID3D12ShaderReflectionVariable *LPD3D12SHADERREFLECTIONVARIABLE;
+
+typedef interface ID3D12ShaderReflectionConstantBuffer ID3D12ShaderReflectionConstantBuffer;
+typedef interface ID3D12ShaderReflectionConstantBuffer *LPD3D12SHADERREFLECTIONCONSTANTBUFFER;
+
+typedef interface ID3D12ShaderReflection ID3D12ShaderReflection;
+typedef interface ID3D12ShaderReflection *LPD3D12SHADERREFLECTION;
+
+typedef interface ID3D12LibraryReflection ID3D12LibraryReflection;
+typedef interface ID3D12LibraryReflection *LPD3D12LIBRARYREFLECTION;
+
+typedef interface ID3D12FunctionReflection ID3D12FunctionReflection;
+typedef interface ID3D12FunctionReflection *LPD3D12FUNCTIONREFLECTION;
+
+typedef interface ID3D12FunctionParameterReflection ID3D12FunctionParameterReflection;
+typedef interface ID3D12FunctionParameterReflection *LPD3D12FUNCTIONPARAMETERREFLECTION;
+
+
+// {E913C351-783D-48CA-A1D1-4F306284AD56}
+interface DECLSPEC_UUID("E913C351-783D-48CA-A1D1-4F306284AD56") ID3D12ShaderReflectionType;
+DEFINE_GUID(IID_ID3D12ShaderReflectionType, 
+0xe913c351, 0x783d, 0x48ca, 0xa1, 0xd1, 0x4f, 0x30, 0x62, 0x84, 0xad, 0x56);
+
+#undef INTERFACE
+#define INTERFACE ID3D12ShaderReflectionType
+
+DECLARE_INTERFACE(ID3D12ShaderReflectionType)
+{
+    STDMETHOD(GetDesc)(THIS_ _Out_ D3D12_SHADER_TYPE_DESC *pDesc) PURE;
+    
+    STDMETHOD_(ID3D12ShaderReflectionType*, GetMemberTypeByIndex)(THIS_ _In_ UINT Index) PURE;
+    STDMETHOD_(ID3D12ShaderReflectionType*, GetMemberTypeByName)(THIS_ _In_ LPCSTR Name) PURE;
+    STDMETHOD_(LPCSTR, GetMemberTypeName)(THIS_ _In_ UINT Index) PURE;
+
+    STDMETHOD(IsEqual)(THIS_ _In_ ID3D12ShaderReflectionType* pType) PURE;
+    STDMETHOD_(ID3D12ShaderReflectionType*, GetSubType)(THIS) PURE;
+    STDMETHOD_(ID3D12ShaderReflectionType*, GetBaseClass)(THIS) PURE;
+    STDMETHOD_(UINT, GetNumInterfaces)(THIS) PURE;
+    STDMETHOD_(ID3D12ShaderReflectionType*, GetInterfaceByIndex)(THIS_ _In_ UINT uIndex) PURE;
+    STDMETHOD(IsOfType)(THIS_ _In_ ID3D12ShaderReflectionType* pType) PURE;
+    STDMETHOD(ImplementsInterface)(THIS_ _In_ ID3D12ShaderReflectionType* pBase) PURE;
+};
+
+// {8337A8A6-A216-444A-B2F4-314733A73AEA}
+interface DECLSPEC_UUID("8337A8A6-A216-444A-B2F4-314733A73AEA") ID3D12ShaderReflectionVariable;
+DEFINE_GUID(IID_ID3D12ShaderReflectionVariable, 
+0x8337a8a6, 0xa216, 0x444a, 0xb2, 0xf4, 0x31, 0x47, 0x33, 0xa7, 0x3a, 0xea);
+
+#undef INTERFACE
+#define INTERFACE ID3D12ShaderReflectionVariable
+
+DECLARE_INTERFACE(ID3D12ShaderReflectionVariable)
+{
+    STDMETHOD(GetDesc)(THIS_ _Out_ D3D12_SHADER_VARIABLE_DESC *pDesc) PURE;
+    
+    STDMETHOD_(ID3D12ShaderReflectionType*, GetType)(THIS) PURE;
+    STDMETHOD_(ID3D12ShaderReflectionConstantBuffer*, GetBuffer)(THIS) PURE;
+
+    STDMETHOD_(UINT, GetInterfaceSlot)(THIS_ _In_ UINT uArrayIndex) PURE;
+};
+
+// {C59598B4-48B3-4869-B9B1-B1618B14A8B7}
+interface DECLSPEC_UUID("C59598B4-48B3-4869-B9B1-B1618B14A8B7") ID3D12ShaderReflectionConstantBuffer;
+DEFINE_GUID(IID_ID3D12ShaderReflectionConstantBuffer, 
+0xc59598b4, 0x48b3, 0x4869, 0xb9, 0xb1, 0xb1, 0x61, 0x8b, 0x14, 0xa8, 0xb7);
+
+#undef INTERFACE
+#define INTERFACE ID3D12ShaderReflectionConstantBuffer
+
+DECLARE_INTERFACE(ID3D12ShaderReflectionConstantBuffer)
+{
+    STDMETHOD(GetDesc)(THIS_ D3D12_SHADER_BUFFER_DESC *pDesc) PURE;
+    
+    STDMETHOD_(ID3D12ShaderReflectionVariable*, GetVariableByIndex)(THIS_ _In_ UINT Index) PURE;
+    STDMETHOD_(ID3D12ShaderReflectionVariable*, GetVariableByName)(THIS_ _In_ LPCSTR Name) PURE;
+};
+
+// The ID3D12ShaderReflection IID may change from SDK version to SDK version
+// if the reflection API changes.  This prevents new code with the new API
+// from working with an old binary.  Recompiling with the new header
+// will pick up the new IID.
+
+// {5A58797D-A72C-478D-8BA2-EFC6B0EFE88E}
+interface DECLSPEC_UUID("5A58797D-A72C-478D-8BA2-EFC6B0EFE88E") ID3D12ShaderReflection;
+DEFINE_GUID(IID_ID3D12ShaderReflection, 
+0x5a58797d, 0xa72c, 0x478d, 0x8b, 0xa2, 0xef, 0xc6, 0xb0, 0xef, 0xe8, 0x8e);
+
+#undef INTERFACE
+#define INTERFACE ID3D12ShaderReflection
+
+DECLARE_INTERFACE_(ID3D12ShaderReflection, IUnknown)
+{
+    STDMETHOD(QueryInterface)(THIS_ _In_ REFIID iid,
+                              _Out_ LPVOID *ppv) PURE;
+    STDMETHOD_(ULONG, AddRef)(THIS) PURE;
+    STDMETHOD_(ULONG, Release)(THIS) PURE;
+
+    STDMETHOD(GetDesc)(THIS_ _Out_ D3D12_SHADER_DESC *pDesc) PURE;
+    
+    STDMETHOD_(ID3D12ShaderReflectionConstantBuffer*, GetConstantBufferByIndex)(THIS_ _In_ UINT Index) PURE;
+    STDMETHOD_(ID3D12ShaderReflectionConstantBuffer*, GetConstantBufferByName)(THIS_ _In_ LPCSTR Name) PURE;
+    
+    STDMETHOD(GetResourceBindingDesc)(THIS_ _In_ UINT ResourceIndex,
+                                      _Out_ D3D12_SHADER_INPUT_BIND_DESC *pDesc) PURE;
+    
+    STDMETHOD(GetInputParameterDesc)(THIS_ _In_ UINT ParameterIndex,
+                                     _Out_ D3D12_SIGNATURE_PARAMETER_DESC *pDesc) PURE;
+    STDMETHOD(GetOutputParameterDesc)(THIS_ _In_ UINT ParameterIndex,
+                                      _Out_ D3D12_SIGNATURE_PARAMETER_DESC *pDesc) PURE;
+    STDMETHOD(GetPatchConstantParameterDesc)(THIS_ _In_ UINT ParameterIndex,
+                                             _Out_ D3D12_SIGNATURE_PARAMETER_DESC *pDesc) PURE;
+
+    STDMETHOD_(ID3D12ShaderReflectionVariable*, GetVariableByName)(THIS_ _In_ LPCSTR Name) PURE;
+
+    STDMETHOD(GetResourceBindingDescByName)(THIS_ _In_ LPCSTR Name,
+                                            _Out_ D3D12_SHADER_INPUT_BIND_DESC *pDesc) PURE;
+
+    STDMETHOD_(UINT, GetMovInstructionCount)(THIS) PURE;
+    STDMETHOD_(UINT, GetMovcInstructionCount)(THIS) PURE;
+    STDMETHOD_(UINT, GetConversionInstructionCount)(THIS) PURE;
+    STDMETHOD_(UINT, GetBitwiseInstructionCount)(THIS) PURE;
+    
+    STDMETHOD_(D3D_PRIMITIVE, GetGSInputPrimitive)(THIS) PURE;
+    STDMETHOD_(BOOL, IsSampleFrequencyShader)(THIS) PURE;
+
+    STDMETHOD_(UINT, GetNumInterfaceSlots)(THIS) PURE;
+    STDMETHOD(GetMinFeatureLevel)(THIS_ _Out_ enum D3D_FEATURE_LEVEL* pLevel) PURE;
+
+    STDMETHOD_(UINT, GetThreadGroupSize)(THIS_
+                                         _Out_opt_ UINT* pSizeX,
+                                         _Out_opt_ UINT* pSizeY,
+                                         _Out_opt_ UINT* pSizeZ) PURE;
+
+    STDMETHOD_(UINT64, GetRequiresFlags)(THIS) PURE;
+};
+
+// {8E349D19-54DB-4A56-9DC9-119D87BDB804}
+interface DECLSPEC_UUID("8E349D19-54DB-4A56-9DC9-119D87BDB804") ID3D12LibraryReflection;
+DEFINE_GUID(IID_ID3D12LibraryReflection, 
+0x8e349d19, 0x54db, 0x4a56, 0x9d, 0xc9, 0x11, 0x9d, 0x87, 0xbd, 0xb8, 0x4);
+
+#undef INTERFACE
+#define INTERFACE ID3D12LibraryReflection
+
+DECLARE_INTERFACE_(ID3D12LibraryReflection, IUnknown)
+{
+    STDMETHOD(QueryInterface)(THIS_ _In_ REFIID iid, _Out_ LPVOID * ppv) PURE;
+    STDMETHOD_(ULONG, AddRef)(THIS) PURE;
+    STDMETHOD_(ULONG, Release)(THIS) PURE;
+
+    STDMETHOD(GetDesc)(THIS_ _Out_ D3D12_LIBRARY_DESC * pDesc) PURE;
+    
+    STDMETHOD_(ID3D12FunctionReflection *, GetFunctionByIndex)(THIS_ _In_ INT FunctionIndex) PURE;
+};
+
+// {1108795C-2772-4BA9-B2A8-D464DC7E2799}
+interface DECLSPEC_UUID("1108795C-2772-4BA9-B2A8-D464DC7E2799") ID3D12FunctionReflection;
+DEFINE_GUID(IID_ID3D12FunctionReflection, 
+0x1108795c, 0x2772, 0x4ba9, 0xb2, 0xa8, 0xd4, 0x64, 0xdc, 0x7e, 0x27, 0x99);
+
+#undef INTERFACE
+#define INTERFACE ID3D12FunctionReflection
+
+DECLARE_INTERFACE(ID3D12FunctionReflection)
+{
+    STDMETHOD(GetDesc)(THIS_ _Out_ D3D12_FUNCTION_DESC * pDesc) PURE;
+    
+    STDMETHOD_(ID3D12ShaderReflectionConstantBuffer *, GetConstantBufferByIndex)(THIS_ _In_ UINT BufferIndex) PURE;
+    STDMETHOD_(ID3D12ShaderReflectionConstantBuffer *, GetConstantBufferByName)(THIS_ _In_ LPCSTR Name) PURE;
+    
+    STDMETHOD(GetResourceBindingDesc)(THIS_ _In_ UINT ResourceIndex,
+                                      _Out_ D3D12_SHADER_INPUT_BIND_DESC * pDesc) PURE;
+    
+    STDMETHOD_(ID3D12ShaderReflectionVariable *, GetVariableByName)(THIS_ _In_ LPCSTR Name) PURE;
+
+    STDMETHOD(GetResourceBindingDescByName)(THIS_ _In_ LPCSTR Name,
+                                            _Out_ D3D12_SHADER_INPUT_BIND_DESC * pDesc) PURE;
+
+    // Use D3D_RETURN_PARAMETER_INDEX to get description of the return value.
+    STDMETHOD_(ID3D12FunctionParameterReflection *, GetFunctionParameter)(THIS_ _In_ INT ParameterIndex) PURE;
+};
+
+// {EC25F42D-7006-4F2B-B33E-02CC3375733F}
+interface DECLSPEC_UUID("EC25F42D-7006-4F2B-B33E-02CC3375733F") ID3D12FunctionParameterReflection;
+DEFINE_GUID(IID_ID3D12FunctionParameterReflection, 
+0xec25f42d, 0x7006, 0x4f2b, 0xb3, 0x3e, 0x2, 0xcc, 0x33, 0x75, 0x73, 0x3f);
+
+#undef INTERFACE
+#define INTERFACE ID3D12FunctionParameterReflection
+
+DECLARE_INTERFACE(ID3D12FunctionParameterReflection)
+{
+    STDMETHOD(GetDesc)(THIS_ _Out_ D3D12_PARAMETER_DESC * pDesc) PURE;
+};
+
+
+//////////////////////////////////////////////////////////////////////////////
+// APIs //////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////////
+
+#ifdef __cplusplus
+extern "C" {
+#endif //__cplusplus
+
+#ifdef __cplusplus
+}
+#endif //__cplusplus
+    
+#endif //__D3D12SHADER_H__
+

EscapeTheBackroomsGUiTest/vcpkg_Out/include/directx/d3dcommon.idl

@@ -0,0 +1,964 @@
+/*-------------------------------------------------------------------------------------
+ *
+ * Copyright (c) Microsoft Corporation
+ * Licensed under the MIT license
+ *
+ *-------------------------------------------------------------------------------------*/
+import "oaidl.idl";
+import "ocidl.idl";
+
+//----------------------------------------------------------------------------
+//
+// D3D-version-neutral runtime information.
+//
+//----------------------------------------------------------------------------
+
+typedef enum D3D_DRIVER_TYPE
+{
+    D3D_DRIVER_TYPE_UNKNOWN,
+    D3D_DRIVER_TYPE_HARDWARE,
+    D3D_DRIVER_TYPE_REFERENCE,
+    D3D_DRIVER_TYPE_NULL,
+    D3D_DRIVER_TYPE_SOFTWARE,
+    D3D_DRIVER_TYPE_WARP,
+} D3D_DRIVER_TYPE;
+
+typedef enum D3D_FEATURE_LEVEL
+{
+    D3D_FEATURE_LEVEL_1_0_CORE = 0x1000,
+    D3D_FEATURE_LEVEL_9_1 = 0x9100,
+    D3D_FEATURE_LEVEL_9_2 = 0x9200,
+    D3D_FEATURE_LEVEL_9_3 = 0x9300,
+    D3D_FEATURE_LEVEL_10_0 = 0xa000,
+    D3D_FEATURE_LEVEL_10_1 = 0xa100,
+    D3D_FEATURE_LEVEL_11_0 = 0xb000,
+    D3D_FEATURE_LEVEL_11_1 = 0xb100,
+    D3D_FEATURE_LEVEL_12_0 = 0xc000,
+    D3D_FEATURE_LEVEL_12_1 = 0xc100,
+    D3D_FEATURE_LEVEL_12_2 = 0xc200
+} D3D_FEATURE_LEVEL;
+
+cpp_quote("#define D3D_FL9_1_REQ_TEXTURE1D_U_DIMENSION          2048")
+cpp_quote("#define D3D_FL9_3_REQ_TEXTURE1D_U_DIMENSION          4096")
+cpp_quote("#define D3D_FL9_1_REQ_TEXTURE2D_U_OR_V_DIMENSION     2048")
+cpp_quote("#define D3D_FL9_3_REQ_TEXTURE2D_U_OR_V_DIMENSION     4096")
+cpp_quote("#define D3D_FL9_1_REQ_TEXTURECUBE_DIMENSION          512")
+cpp_quote("#define D3D_FL9_3_REQ_TEXTURECUBE_DIMENSION          4096")
+cpp_quote("#define D3D_FL9_1_REQ_TEXTURE3D_U_V_OR_W_DIMENSION   256")
+cpp_quote("#define D3D_FL9_1_DEFAULT_MAX_ANISOTROPY             2")
+cpp_quote("#define D3D_FL9_1_IA_PRIMITIVE_MAX_COUNT             65535")
+cpp_quote("#define D3D_FL9_2_IA_PRIMITIVE_MAX_COUNT             1048575")
+cpp_quote("#define D3D_FL9_1_SIMULTANEOUS_RENDER_TARGET_COUNT   1")
+cpp_quote("#define D3D_FL9_3_SIMULTANEOUS_RENDER_TARGET_COUNT   4")
+cpp_quote("#define D3D_FL9_1_MAX_TEXTURE_REPEAT                 128")
+cpp_quote("#define D3D_FL9_2_MAX_TEXTURE_REPEAT                 2048")
+cpp_quote("#define D3D_FL9_3_MAX_TEXTURE_REPEAT                 8192")
+
+typedef enum D3D_PRIMITIVE_TOPOLOGY
+{
+    D3D_PRIMITIVE_TOPOLOGY_UNDEFINED = 0,
+    D3D_PRIMITIVE_TOPOLOGY_POINTLIST = 1,
+    D3D_PRIMITIVE_TOPOLOGY_LINELIST = 2,
+    D3D_PRIMITIVE_TOPOLOGY_LINESTRIP = 3,
+    D3D_PRIMITIVE_TOPOLOGY_TRIANGLELIST = 4,
+    D3D_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP = 5,
+    D3D_PRIMITIVE_TOPOLOGY_TRIANGLEFAN = 6,
+    // Adjacency values should be equal to (0x8 & non-adjacency):
+    D3D_PRIMITIVE_TOPOLOGY_LINELIST_ADJ = 10,
+    D3D_PRIMITIVE_TOPOLOGY_LINESTRIP_ADJ = 11,
+    D3D_PRIMITIVE_TOPOLOGY_TRIANGLELIST_ADJ = 12,
+    D3D_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP_ADJ = 13,
+    D3D_PRIMITIVE_TOPOLOGY_1_CONTROL_POINT_PATCHLIST = 33,
+    D3D_PRIMITIVE_TOPOLOGY_2_CONTROL_POINT_PATCHLIST = 34,
+    D3D_PRIMITIVE_TOPOLOGY_3_CONTROL_POINT_PATCHLIST = 35,
+    D3D_PRIMITIVE_TOPOLOGY_4_CONTROL_POINT_PATCHLIST = 36,
+    D3D_PRIMITIVE_TOPOLOGY_5_CONTROL_POINT_PATCHLIST = 37,
+    D3D_PRIMITIVE_TOPOLOGY_6_CONTROL_POINT_PATCHLIST = 38,
+    D3D_PRIMITIVE_TOPOLOGY_7_CONTROL_POINT_PATCHLIST = 39,
+    D3D_PRIMITIVE_TOPOLOGY_8_CONTROL_POINT_PATCHLIST = 40,
+    D3D_PRIMITIVE_TOPOLOGY_9_CONTROL_POINT_PATCHLIST = 41,
+    D3D_PRIMITIVE_TOPOLOGY_10_CONTROL_POINT_PATCHLIST = 42,
+    D3D_PRIMITIVE_TOPOLOGY_11_CONTROL_POINT_PATCHLIST = 43,
+    D3D_PRIMITIVE_TOPOLOGY_12_CONTROL_POINT_PATCHLIST = 44,
+    D3D_PRIMITIVE_TOPOLOGY_13_CONTROL_POINT_PATCHLIST = 45,
+    D3D_PRIMITIVE_TOPOLOGY_14_CONTROL_POINT_PATCHLIST = 46,
+    D3D_PRIMITIVE_TOPOLOGY_15_CONTROL_POINT_PATCHLIST = 47,
+    D3D_PRIMITIVE_TOPOLOGY_16_CONTROL_POINT_PATCHLIST = 48,
+    D3D_PRIMITIVE_TOPOLOGY_17_CONTROL_POINT_PATCHLIST = 49,
+    D3D_PRIMITIVE_TOPOLOGY_18_CONTROL_POINT_PATCHLIST = 50,
+    D3D_PRIMITIVE_TOPOLOGY_19_CONTROL_POINT_PATCHLIST = 51,
+    D3D_PRIMITIVE_TOPOLOGY_20_CONTROL_POINT_PATCHLIST = 52,
+    D3D_PRIMITIVE_TOPOLOGY_21_CONTROL_POINT_PATCHLIST = 53,
+    D3D_PRIMITIVE_TOPOLOGY_22_CONTROL_POINT_PATCHLIST = 54,
+    D3D_PRIMITIVE_TOPOLOGY_23_CONTROL_POINT_PATCHLIST = 55,
+    D3D_PRIMITIVE_TOPOLOGY_24_CONTROL_POINT_PATCHLIST = 56,
+    D3D_PRIMITIVE_TOPOLOGY_25_CONTROL_POINT_PATCHLIST = 57,
+    D3D_PRIMITIVE_TOPOLOGY_26_CONTROL_POINT_PATCHLIST = 58,
+    D3D_PRIMITIVE_TOPOLOGY_27_CONTROL_POINT_PATCHLIST = 59,
+    D3D_PRIMITIVE_TOPOLOGY_28_CONTROL_POINT_PATCHLIST = 60,
+    D3D_PRIMITIVE_TOPOLOGY_29_CONTROL_POINT_PATCHLIST = 61,
+    D3D_PRIMITIVE_TOPOLOGY_30_CONTROL_POINT_PATCHLIST = 62,
+    D3D_PRIMITIVE_TOPOLOGY_31_CONTROL_POINT_PATCHLIST = 63,
+    D3D_PRIMITIVE_TOPOLOGY_32_CONTROL_POINT_PATCHLIST = 64,
+
+    D3D10_PRIMITIVE_TOPOLOGY_UNDEFINED = D3D_PRIMITIVE_TOPOLOGY_UNDEFINED,
+    D3D10_PRIMITIVE_TOPOLOGY_POINTLIST = D3D_PRIMITIVE_TOPOLOGY_POINTLIST,
+    D3D10_PRIMITIVE_TOPOLOGY_LINELIST = D3D_PRIMITIVE_TOPOLOGY_LINELIST,
+    D3D10_PRIMITIVE_TOPOLOGY_LINESTRIP = D3D_PRIMITIVE_TOPOLOGY_LINESTRIP,
+    D3D10_PRIMITIVE_TOPOLOGY_TRIANGLELIST = D3D_PRIMITIVE_TOPOLOGY_TRIANGLELIST,
+    D3D10_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP = D3D_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP,
+    D3D10_PRIMITIVE_TOPOLOGY_LINELIST_ADJ = D3D_PRIMITIVE_TOPOLOGY_LINELIST_ADJ,
+    D3D10_PRIMITIVE_TOPOLOGY_LINESTRIP_ADJ = D3D_PRIMITIVE_TOPOLOGY_LINESTRIP_ADJ,
+    D3D10_PRIMITIVE_TOPOLOGY_TRIANGLELIST_ADJ = D3D_PRIMITIVE_TOPOLOGY_TRIANGLELIST_ADJ,
+    D3D10_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP_ADJ = D3D_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP_ADJ,
+
+    D3D11_PRIMITIVE_TOPOLOGY_UNDEFINED = D3D_PRIMITIVE_TOPOLOGY_UNDEFINED,
+    D3D11_PRIMITIVE_TOPOLOGY_POINTLIST = D3D_PRIMITIVE_TOPOLOGY_POINTLIST,
+    D3D11_PRIMITIVE_TOPOLOGY_LINELIST = D3D_PRIMITIVE_TOPOLOGY_LINELIST,
+    D3D11_PRIMITIVE_TOPOLOGY_LINESTRIP = D3D_PRIMITIVE_TOPOLOGY_LINESTRIP,
+    D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST = D3D_PRIMITIVE_TOPOLOGY_TRIANGLELIST,
+    D3D11_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP = D3D_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP,
+    D3D11_PRIMITIVE_TOPOLOGY_LINELIST_ADJ = D3D_PRIMITIVE_TOPOLOGY_LINELIST_ADJ,
+    D3D11_PRIMITIVE_TOPOLOGY_LINESTRIP_ADJ = D3D_PRIMITIVE_TOPOLOGY_LINESTRIP_ADJ,
+    D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST_ADJ = D3D_PRIMITIVE_TOPOLOGY_TRIANGLELIST_ADJ,
+    D3D11_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP_ADJ = D3D_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP_ADJ,
+    D3D11_PRIMITIVE_TOPOLOGY_1_CONTROL_POINT_PATCHLIST = D3D_PRIMITIVE_TOPOLOGY_1_CONTROL_POINT_PATCHLIST,
+    D3D11_PRIMITIVE_TOPOLOGY_2_CONTROL_POINT_PATCHLIST = D3D_PRIMITIVE_TOPOLOGY_2_CONTROL_POINT_PATCHLIST,
+    D3D11_PRIMITIVE_TOPOLOGY_3_CONTROL_POINT_PATCHLIST = D3D_PRIMITIVE_TOPOLOGY_3_CONTROL_POINT_PATCHLIST,
+    D3D11_PRIMITIVE_TOPOLOGY_4_CONTROL_POINT_PATCHLIST = D3D_PRIMITIVE_TOPOLOGY_4_CONTROL_POINT_PATCHLIST,
+    D3D11_PRIMITIVE_TOPOLOGY_5_CONTROL_POINT_PATCHLIST = D3D_PRIMITIVE_TOPOLOGY_5_CONTROL_POINT_PATCHLIST,
+    D3D11_PRIMITIVE_TOPOLOGY_6_CONTROL_POINT_PATCHLIST = D3D_PRIMITIVE_TOPOLOGY_6_CONTROL_POINT_PATCHLIST,
+    D3D11_PRIMITIVE_TOPOLOGY_7_CONTROL_POINT_PATCHLIST = D3D_PRIMITIVE_TOPOLOGY_7_CONTROL_POINT_PATCHLIST,
+    D3D11_PRIMITIVE_TOPOLOGY_8_CONTROL_POINT_PATCHLIST = D3D_PRIMITIVE_TOPOLOGY_8_CONTROL_POINT_PATCHLIST,
+    D3D11_PRIMITIVE_TOPOLOGY_9_CONTROL_POINT_PATCHLIST = D3D_PRIMITIVE_TOPOLOGY_9_CONTROL_POINT_PATCHLIST,
+    D3D11_PRIMITIVE_TOPOLOGY_10_CONTROL_POINT_PATCHLIST = D3D_PRIMITIVE_TOPOLOGY_10_CONTROL_POINT_PATCHLIST,
+    D3D11_PRIMITIVE_TOPOLOGY_11_CONTROL_POINT_PATCHLIST = D3D_PRIMITIVE_TOPOLOGY_11_CONTROL_POINT_PATCHLIST,
+    D3D11_PRIMITIVE_TOPOLOGY_12_CONTROL_POINT_PATCHLIST = D3D_PRIMITIVE_TOPOLOGY_12_CONTROL_POINT_PATCHLIST,
+    D3D11_PRIMITIVE_TOPOLOGY_13_CONTROL_POINT_PATCHLIST = D3D_PRIMITIVE_TOPOLOGY_13_CONTROL_POINT_PATCHLIST,
+    D3D11_PRIMITIVE_TOPOLOGY_14_CONTROL_POINT_PATCHLIST = D3D_PRIMITIVE_TOPOLOGY_14_CONTROL_POINT_PATCHLIST,
+    D3D11_PRIMITIVE_TOPOLOGY_15_CONTROL_POINT_PATCHLIST = D3D_PRIMITIVE_TOPOLOGY_15_CONTROL_POINT_PATCHLIST,
+    D3D11_PRIMITIVE_TOPOLOGY_16_CONTROL_POINT_PATCHLIST = D3D_PRIMITIVE_TOPOLOGY_16_CONTROL_POINT_PATCHLIST,
+    D3D11_PRIMITIVE_TOPOLOGY_17_CONTROL_POINT_PATCHLIST = D3D_PRIMITIVE_TOPOLOGY_17_CONTROL_POINT_PATCHLIST,
+    D3D11_PRIMITIVE_TOPOLOGY_18_CONTROL_POINT_PATCHLIST = D3D_PRIMITIVE_TOPOLOGY_18_CONTROL_POINT_PATCHLIST,
+    D3D11_PRIMITIVE_TOPOLOGY_19_CONTROL_POINT_PATCHLIST = D3D_PRIMITIVE_TOPOLOGY_19_CONTROL_POINT_PATCHLIST,
+    D3D11_PRIMITIVE_TOPOLOGY_20_CONTROL_POINT_PATCHLIST = D3D_PRIMITIVE_TOPOLOGY_20_CONTROL_POINT_PATCHLIST,
+    D3D11_PRIMITIVE_TOPOLOGY_21_CONTROL_POINT_PATCHLIST = D3D_PRIMITIVE_TOPOLOGY_21_CONTROL_POINT_PATCHLIST,
+    D3D11_PRIMITIVE_TOPOLOGY_22_CONTROL_POINT_PATCHLIST = D3D_PRIMITIVE_TOPOLOGY_22_CONTROL_POINT_PATCHLIST,
+    D3D11_PRIMITIVE_TOPOLOGY_23_CONTROL_POINT_PATCHLIST = D3D_PRIMITIVE_TOPOLOGY_23_CONTROL_POINT_PATCHLIST,
+    D3D11_PRIMITIVE_TOPOLOGY_24_CONTROL_POINT_PATCHLIST = D3D_PRIMITIVE_TOPOLOGY_24_CONTROL_POINT_PATCHLIST,
+    D3D11_PRIMITIVE_TOPOLOGY_25_CONTROL_POINT_PATCHLIST = D3D_PRIMITIVE_TOPOLOGY_25_CONTROL_POINT_PATCHLIST,
+    D3D11_PRIMITIVE_TOPOLOGY_26_CONTROL_POINT_PATCHLIST = D3D_PRIMITIVE_TOPOLOGY_26_CONTROL_POINT_PATCHLIST,
+    D3D11_PRIMITIVE_TOPOLOGY_27_CONTROL_POINT_PATCHLIST = D3D_PRIMITIVE_TOPOLOGY_27_CONTROL_POINT_PATCHLIST,
+    D3D11_PRIMITIVE_TOPOLOGY_28_CONTROL_POINT_PATCHLIST = D3D_PRIMITIVE_TOPOLOGY_28_CONTROL_POINT_PATCHLIST,
+    D3D11_PRIMITIVE_TOPOLOGY_29_CONTROL_POINT_PATCHLIST = D3D_PRIMITIVE_TOPOLOGY_29_CONTROL_POINT_PATCHLIST,
+    D3D11_PRIMITIVE_TOPOLOGY_30_CONTROL_POINT_PATCHLIST = D3D_PRIMITIVE_TOPOLOGY_30_CONTROL_POINT_PATCHLIST,
+    D3D11_PRIMITIVE_TOPOLOGY_31_CONTROL_POINT_PATCHLIST = D3D_PRIMITIVE_TOPOLOGY_31_CONTROL_POINT_PATCHLIST,
+    D3D11_PRIMITIVE_TOPOLOGY_32_CONTROL_POINT_PATCHLIST = D3D_PRIMITIVE_TOPOLOGY_32_CONTROL_POINT_PATCHLIST
+} D3D_PRIMITIVE_TOPOLOGY;
+
+typedef enum D3D_PRIMITIVE
+{
+    D3D_PRIMITIVE_UNDEFINED = 0,
+    D3D_PRIMITIVE_POINT = 1,
+    D3D_PRIMITIVE_LINE = 2,
+    D3D_PRIMITIVE_TRIANGLE = 3,
+    // Adjacency values should be equal to (0x4 & non-adjacency):
+    D3D_PRIMITIVE_LINE_ADJ = 6,
+    D3D_PRIMITIVE_TRIANGLE_ADJ = 7,
+    D3D_PRIMITIVE_1_CONTROL_POINT_PATCH = 8,
+    D3D_PRIMITIVE_2_CONTROL_POINT_PATCH = 9,
+    D3D_PRIMITIVE_3_CONTROL_POINT_PATCH = 10,
+    D3D_PRIMITIVE_4_CONTROL_POINT_PATCH = 11,
+    D3D_PRIMITIVE_5_CONTROL_POINT_PATCH = 12,
+    D3D_PRIMITIVE_6_CONTROL_POINT_PATCH = 13,
+    D3D_PRIMITIVE_7_CONTROL_POINT_PATCH = 14,
+    D3D_PRIMITIVE_8_CONTROL_POINT_PATCH = 15,
+    D3D_PRIMITIVE_9_CONTROL_POINT_PATCH = 16,
+    D3D_PRIMITIVE_10_CONTROL_POINT_PATCH = 17,
+    D3D_PRIMITIVE_11_CONTROL_POINT_PATCH = 18,
+    D3D_PRIMITIVE_12_CONTROL_POINT_PATCH = 19,
+    D3D_PRIMITIVE_13_CONTROL_POINT_PATCH = 20,
+    D3D_PRIMITIVE_14_CONTROL_POINT_PATCH = 21,
+    D3D_PRIMITIVE_15_CONTROL_POINT_PATCH = 22,
+    D3D_PRIMITIVE_16_CONTROL_POINT_PATCH = 23,
+    D3D_PRIMITIVE_17_CONTROL_POINT_PATCH = 24,
+    D3D_PRIMITIVE_18_CONTROL_POINT_PATCH = 25,
+    D3D_PRIMITIVE_19_CONTROL_POINT_PATCH = 26,
+    D3D_PRIMITIVE_20_CONTROL_POINT_PATCH = 27,
+    D3D_PRIMITIVE_21_CONTROL_POINT_PATCH = 28,
+    D3D_PRIMITIVE_22_CONTROL_POINT_PATCH = 29,
+    D3D_PRIMITIVE_23_CONTROL_POINT_PATCH = 30,
+    D3D_PRIMITIVE_24_CONTROL_POINT_PATCH = 31,
+    D3D_PRIMITIVE_25_CONTROL_POINT_PATCH = 32,
+    D3D_PRIMITIVE_26_CONTROL_POINT_PATCH = 33,
+    D3D_PRIMITIVE_27_CONTROL_POINT_PATCH = 34,
+    D3D_PRIMITIVE_28_CONTROL_POINT_PATCH = 35,
+    D3D_PRIMITIVE_29_CONTROL_POINT_PATCH = 36,
+    D3D_PRIMITIVE_30_CONTROL_POINT_PATCH = 37,
+    D3D_PRIMITIVE_31_CONTROL_POINT_PATCH = 38,
+    D3D_PRIMITIVE_32_CONTROL_POINT_PATCH = 39,
+
+    D3D10_PRIMITIVE_UNDEFINED = D3D_PRIMITIVE_UNDEFINED,
+    D3D10_PRIMITIVE_POINT = D3D_PRIMITIVE_POINT,
+    D3D10_PRIMITIVE_LINE = D3D_PRIMITIVE_LINE,
+    D3D10_PRIMITIVE_TRIANGLE = D3D_PRIMITIVE_TRIANGLE,
+    D3D10_PRIMITIVE_LINE_ADJ = D3D_PRIMITIVE_LINE_ADJ,
+    D3D10_PRIMITIVE_TRIANGLE_ADJ = D3D_PRIMITIVE_TRIANGLE_ADJ,
+
+    D3D11_PRIMITIVE_UNDEFINED = D3D_PRIMITIVE_UNDEFINED,
+    D3D11_PRIMITIVE_POINT = D3D_PRIMITIVE_POINT,
+    D3D11_PRIMITIVE_LINE = D3D_PRIMITIVE_LINE,
+    D3D11_PRIMITIVE_TRIANGLE = D3D_PRIMITIVE_TRIANGLE,
+    D3D11_PRIMITIVE_LINE_ADJ = D3D_PRIMITIVE_LINE_ADJ,
+    D3D11_PRIMITIVE_TRIANGLE_ADJ = D3D_PRIMITIVE_TRIANGLE_ADJ,
+    D3D11_PRIMITIVE_1_CONTROL_POINT_PATCH = D3D_PRIMITIVE_1_CONTROL_POINT_PATCH,
+    D3D11_PRIMITIVE_2_CONTROL_POINT_PATCH = D3D_PRIMITIVE_2_CONTROL_POINT_PATCH,
+    D3D11_PRIMITIVE_3_CONTROL_POINT_PATCH = D3D_PRIMITIVE_3_CONTROL_POINT_PATCH,
+    D3D11_PRIMITIVE_4_CONTROL_POINT_PATCH = D3D_PRIMITIVE_4_CONTROL_POINT_PATCH,
+    D3D11_PRIMITIVE_5_CONTROL_POINT_PATCH = D3D_PRIMITIVE_5_CONTROL_POINT_PATCH,
+    D3D11_PRIMITIVE_6_CONTROL_POINT_PATCH = D3D_PRIMITIVE_6_CONTROL_POINT_PATCH,
+    D3D11_PRIMITIVE_7_CONTROL_POINT_PATCH = D3D_PRIMITIVE_7_CONTROL_POINT_PATCH,
+    D3D11_PRIMITIVE_8_CONTROL_POINT_PATCH = D3D_PRIMITIVE_8_CONTROL_POINT_PATCH,
+    D3D11_PRIMITIVE_9_CONTROL_POINT_PATCH = D3D_PRIMITIVE_9_CONTROL_POINT_PATCH,
+    D3D11_PRIMITIVE_10_CONTROL_POINT_PATCH = D3D_PRIMITIVE_10_CONTROL_POINT_PATCH,
+    D3D11_PRIMITIVE_11_CONTROL_POINT_PATCH = D3D_PRIMITIVE_11_CONTROL_POINT_PATCH,
+    D3D11_PRIMITIVE_12_CONTROL_POINT_PATCH = D3D_PRIMITIVE_12_CONTROL_POINT_PATCH,
+    D3D11_PRIMITIVE_13_CONTROL_POINT_PATCH = D3D_PRIMITIVE_13_CONTROL_POINT_PATCH,
+    D3D11_PRIMITIVE_14_CONTROL_POINT_PATCH = D3D_PRIMITIVE_14_CONTROL_POINT_PATCH,
+    D3D11_PRIMITIVE_15_CONTROL_POINT_PATCH = D3D_PRIMITIVE_15_CONTROL_POINT_PATCH,
+    D3D11_PRIMITIVE_16_CONTROL_POINT_PATCH = D3D_PRIMITIVE_16_CONTROL_POINT_PATCH,
+    D3D11_PRIMITIVE_17_CONTROL_POINT_PATCH = D3D_PRIMITIVE_17_CONTROL_POINT_PATCH,
+    D3D11_PRIMITIVE_18_CONTROL_POINT_PATCH = D3D_PRIMITIVE_18_CONTROL_POINT_PATCH,
+    D3D11_PRIMITIVE_19_CONTROL_POINT_PATCH = D3D_PRIMITIVE_19_CONTROL_POINT_PATCH,
+    D3D11_PRIMITIVE_20_CONTROL_POINT_PATCH = D3D_PRIMITIVE_20_CONTROL_POINT_PATCH,
+    D3D11_PRIMITIVE_21_CONTROL_POINT_PATCH = D3D_PRIMITIVE_21_CONTROL_POINT_PATCH,
+    D3D11_PRIMITIVE_22_CONTROL_POINT_PATCH = D3D_PRIMITIVE_22_CONTROL_POINT_PATCH,
+    D3D11_PRIMITIVE_23_CONTROL_POINT_PATCH = D3D_PRIMITIVE_23_CONTROL_POINT_PATCH,
+    D3D11_PRIMITIVE_24_CONTROL_POINT_PATCH = D3D_PRIMITIVE_24_CONTROL_POINT_PATCH,
+    D3D11_PRIMITIVE_25_CONTROL_POINT_PATCH = D3D_PRIMITIVE_25_CONTROL_POINT_PATCH,
+    D3D11_PRIMITIVE_26_CONTROL_POINT_PATCH = D3D_PRIMITIVE_26_CONTROL_POINT_PATCH,
+    D3D11_PRIMITIVE_27_CONTROL_POINT_PATCH = D3D_PRIMITIVE_27_CONTROL_POINT_PATCH,
+    D3D11_PRIMITIVE_28_CONTROL_POINT_PATCH = D3D_PRIMITIVE_28_CONTROL_POINT_PATCH,
+    D3D11_PRIMITIVE_29_CONTROL_POINT_PATCH = D3D_PRIMITIVE_29_CONTROL_POINT_PATCH,
+    D3D11_PRIMITIVE_30_CONTROL_POINT_PATCH = D3D_PRIMITIVE_30_CONTROL_POINT_PATCH,
+    D3D11_PRIMITIVE_31_CONTROL_POINT_PATCH = D3D_PRIMITIVE_31_CONTROL_POINT_PATCH,
+    D3D11_PRIMITIVE_32_CONTROL_POINT_PATCH = D3D_PRIMITIVE_32_CONTROL_POINT_PATCH,
+} D3D_PRIMITIVE;
+
+typedef enum D3D_SRV_DIMENSION
+{
+    D3D_SRV_DIMENSION_UNKNOWN = 0,
+    D3D_SRV_DIMENSION_BUFFER = 1,
+    D3D_SRV_DIMENSION_TEXTURE1D = 2,
+    D3D_SRV_DIMENSION_TEXTURE1DARRAY = 3,
+    D3D_SRV_DIMENSION_TEXTURE2D = 4,
+    D3D_SRV_DIMENSION_TEXTURE2DARRAY = 5,
+    D3D_SRV_DIMENSION_TEXTURE2DMS = 6,
+    D3D_SRV_DIMENSION_TEXTURE2DMSARRAY = 7,
+    D3D_SRV_DIMENSION_TEXTURE3D = 8,
+    D3D_SRV_DIMENSION_TEXTURECUBE = 9,
+    D3D_SRV_DIMENSION_TEXTURECUBEARRAY = 10,
+    D3D_SRV_DIMENSION_BUFFEREX = 11,
+
+    D3D10_SRV_DIMENSION_UNKNOWN = D3D_SRV_DIMENSION_UNKNOWN,
+    D3D10_SRV_DIMENSION_BUFFER = D3D_SRV_DIMENSION_BUFFER,
+    D3D10_SRV_DIMENSION_TEXTURE1D = D3D_SRV_DIMENSION_TEXTURE1D,
+    D3D10_SRV_DIMENSION_TEXTURE1DARRAY = D3D_SRV_DIMENSION_TEXTURE1DARRAY,
+    D3D10_SRV_DIMENSION_TEXTURE2D = D3D_SRV_DIMENSION_TEXTURE2D,
+    D3D10_SRV_DIMENSION_TEXTURE2DARRAY = D3D_SRV_DIMENSION_TEXTURE2DARRAY,
+    D3D10_SRV_DIMENSION_TEXTURE2DMS = D3D_SRV_DIMENSION_TEXTURE2DMS,
+    D3D10_SRV_DIMENSION_TEXTURE2DMSARRAY = D3D_SRV_DIMENSION_TEXTURE2DMSARRAY,
+    D3D10_SRV_DIMENSION_TEXTURE3D = D3D_SRV_DIMENSION_TEXTURE3D,
+    D3D10_SRV_DIMENSION_TEXTURECUBE = D3D_SRV_DIMENSION_TEXTURECUBE,
+
+    D3D10_1_SRV_DIMENSION_UNKNOWN = D3D_SRV_DIMENSION_UNKNOWN,
+    D3D10_1_SRV_DIMENSION_BUFFER = D3D_SRV_DIMENSION_BUFFER,
+    D3D10_1_SRV_DIMENSION_TEXTURE1D = D3D_SRV_DIMENSION_TEXTURE1D,
+    D3D10_1_SRV_DIMENSION_TEXTURE1DARRAY = D3D_SRV_DIMENSION_TEXTURE1DARRAY,
+    D3D10_1_SRV_DIMENSION_TEXTURE2D = D3D_SRV_DIMENSION_TEXTURE2D,
+    D3D10_1_SRV_DIMENSION_TEXTURE2DARRAY = D3D_SRV_DIMENSION_TEXTURE2DARRAY,
+    D3D10_1_SRV_DIMENSION_TEXTURE2DMS = D3D_SRV_DIMENSION_TEXTURE2DMS,
+    D3D10_1_SRV_DIMENSION_TEXTURE2DMSARRAY = D3D_SRV_DIMENSION_TEXTURE2DMSARRAY,
+    D3D10_1_SRV_DIMENSION_TEXTURE3D = D3D_SRV_DIMENSION_TEXTURE3D,
+    D3D10_1_SRV_DIMENSION_TEXTURECUBE = D3D_SRV_DIMENSION_TEXTURECUBE,
+    D3D10_1_SRV_DIMENSION_TEXTURECUBEARRAY = D3D_SRV_DIMENSION_TEXTURECUBEARRAY,
+
+    D3D11_SRV_DIMENSION_UNKNOWN = D3D_SRV_DIMENSION_UNKNOWN,
+    D3D11_SRV_DIMENSION_BUFFER = D3D_SRV_DIMENSION_BUFFER,
+    D3D11_SRV_DIMENSION_TEXTURE1D = D3D_SRV_DIMENSION_TEXTURE1D,
+    D3D11_SRV_DIMENSION_TEXTURE1DARRAY = D3D_SRV_DIMENSION_TEXTURE1DARRAY,
+    D3D11_SRV_DIMENSION_TEXTURE2D = D3D_SRV_DIMENSION_TEXTURE2D,
+    D3D11_SRV_DIMENSION_TEXTURE2DARRAY = D3D_SRV_DIMENSION_TEXTURE2DARRAY,
+    D3D11_SRV_DIMENSION_TEXTURE2DMS = D3D_SRV_DIMENSION_TEXTURE2DMS,
+    D3D11_SRV_DIMENSION_TEXTURE2DMSARRAY = D3D_SRV_DIMENSION_TEXTURE2DMSARRAY,
+    D3D11_SRV_DIMENSION_TEXTURE3D = D3D_SRV_DIMENSION_TEXTURE3D,
+    D3D11_SRV_DIMENSION_TEXTURECUBE = D3D_SRV_DIMENSION_TEXTURECUBE,
+    D3D11_SRV_DIMENSION_TEXTURECUBEARRAY = D3D_SRV_DIMENSION_TEXTURECUBEARRAY,
+    D3D11_SRV_DIMENSION_BUFFEREX = D3D_SRV_DIMENSION_BUFFEREX,
+} D3D_SRV_DIMENSION;
+
+// Bits in shaders indicating features they use which the runtime checks against current device support:
+cpp_quote("#define D3D_SHADER_FEATURE_DOUBLES                                                        0x00001")
+cpp_quote("#define D3D_SHADER_FEATURE_COMPUTE_SHADERS_PLUS_RAW_AND_STRUCTURED_BUFFERS_VIA_SHADER_4_X 0x00002")
+cpp_quote("#define D3D_SHADER_FEATURE_UAVS_AT_EVERY_STAGE                                            0x00004")
+cpp_quote("#define D3D_SHADER_FEATURE_64_UAVS                                                        0x00008")
+cpp_quote("#define D3D_SHADER_FEATURE_MINIMUM_PRECISION                                              0x00010")
+cpp_quote("#define D3D_SHADER_FEATURE_11_1_DOUBLE_EXTENSIONS                                         0x00020")
+cpp_quote("#define D3D_SHADER_FEATURE_11_1_SHADER_EXTENSIONS                                         0x00040")
+cpp_quote("#define D3D_SHADER_FEATURE_LEVEL_9_COMPARISON_FILTERING                                   0x00080")
+cpp_quote("#define D3D_SHADER_FEATURE_TILED_RESOURCES                                                0x00100")
+cpp_quote("#define D3D_SHADER_FEATURE_STENCIL_REF                                                    0x00200")
+cpp_quote("#define D3D_SHADER_FEATURE_INNER_COVERAGE                                                 0x00400")
+cpp_quote("#define D3D_SHADER_FEATURE_TYPED_UAV_LOAD_ADDITIONAL_FORMATS                              0x00800")
+cpp_quote("#define D3D_SHADER_FEATURE_ROVS                                                           0x01000")
+cpp_quote("#define D3D_SHADER_FEATURE_VIEWPORT_AND_RT_ARRAY_INDEX_FROM_ANY_SHADER_FEEDING_RASTERIZER 0x02000")
+cpp_quote("#define D3D_SHADER_FEATURE_WAVE_OPS                                                       0x04000")
+cpp_quote("#define D3D_SHADER_FEATURE_INT64_OPS                                                      0x08000")
+cpp_quote("#define D3D_SHADER_FEATURE_VIEW_ID                                                        0x10000")
+cpp_quote("#define D3D_SHADER_FEATURE_BARYCENTRICS                                                   0x20000")
+cpp_quote("#define D3D_SHADER_FEATURE_NATIVE_16BIT_OPS                                               0x40000")
+cpp_quote("#define D3D_SHADER_FEATURE_SHADING_RATE                                                   0x80000")
+cpp_quote("#define D3D_SHADER_FEATURE_RAYTRACING_TIER_1_1                                            0x100000")
+cpp_quote("#define D3D_SHADER_FEATURE_SAMPLER_FEEDBACK                                               0x200000")
+cpp_quote("#define D3D_SHADER_FEATURE_ATOMIC_INT64_ON_TYPED_RESOURCE                                 0x400000")
+cpp_quote("#define D3D_SHADER_FEATURE_ATOMIC_INT64_ON_GROUP_SHARED                                   0x800000")
+cpp_quote("#define D3D_SHADER_FEATURE_DERIVATIVES_IN_MESH_AND_AMPLIFICATION_SHADERS                  0x1000000")
+cpp_quote("#define D3D_SHADER_FEATURE_RESOURCE_DESCRIPTOR_HEAP_INDEXING                              0x2000000")
+cpp_quote("#define D3D_SHADER_FEATURE_SAMPLER_DESCRIPTOR_HEAP_INDEXING                               0x4000000")
+cpp_quote("#define D3D_SHADER_FEATURE_WAVE_MMA                                                       0x8000000")
+cpp_quote("#define D3D_SHADER_FEATURE_ATOMIC_INT64_ON_DESCRIPTOR_HEAP_RESOURCE                       0x10000000")
+cpp_quote("#define D3D_SHADER_FEATURE_ADVANCED_TEXTURE_OPS                                           0x20000000")
+cpp_quote("#define D3D_SHADER_FEATURE_WRITEABLE_MSAA_TEXTURES                                        0x40000000")
+
+// Additional internal shader feature flags are listed in dxbcutils.h (not relevant/useful for public to see)
+// When adding entries here, make sure they don't conflict with what's there.
+
+//----------------------------------------------------------------------------
+//
+// Shader compilation information.
+//
+//----------------------------------------------------------------------------
+
+//----------------------------------------------------------------------------
+// D3D_SHADER_MACRO:
+// ----------
+// Preprocessor macro definition.  The application pass in a NULL-terminated
+// array of this structure to various D3D APIs.  This enables the application
+// to #define tokens at runtime, before the file is parsed.
+//----------------------------------------------------------------------------
+
+typedef struct _D3D_SHADER_MACRO
+{
+    LPCSTR Name;
+    LPCSTR Definition;
+} D3D_SHADER_MACRO, *LPD3D_SHADER_MACRO;
+
+//----------------------------------------------------------------------------
+// ID3DBlob:
+// ------------
+// The buffer object is used by D3D to return arbitrary size data.
+// For compatibility with D3D10 this interface is also called ID3D10Blob,
+// but the version-neutral form is preferred.
+//
+// GetBufferPointer -
+//    Returns a pointer to the beginning of the buffer.
+//
+// GetBufferSize -
+//    Returns the size of the buffer, in bytes.
+//----------------------------------------------------------------------------
+
+// {8BA5FB08-5195-40e2-AC58-0D989C3A0102}
+cpp_quote("DEFINE_GUID(IID_ID3D10Blob, 0x8ba5fb08, 0x5195, 0x40e2, 0xac, 0x58, 0xd, 0x98, 0x9c, 0x3a, 0x1, 0x2);")
+
+[ uuid( 8BA5FB08-5195-40e2-AC58-0D989C3A0102 ), object, local, pointer_default( unique ) ]
+interface ID3D10Blob : IUnknown
+{
+    LPVOID GetBufferPointer();
+    SIZE_T GetBufferSize();
+};
+
+cpp_quote("typedef interface ID3D10Blob* LPD3D10BLOB;")
+
+typedef ID3D10Blob ID3DBlob;
+cpp_quote("typedef ID3DBlob* LPD3DBLOB;")
+cpp_quote("#define IID_ID3DBlob IID_ID3D10Blob")
+
+// ID3DDestructionNotifier: An interface to QI for, to set a callback which is triggered when the object is fully destroyed
+typedef void(__stdcall *PFN_DESTRUCTION_CALLBACK)(void* pData);
+
+[uuid(a06eb39a-50da-425b-8c31-4eecd6c270f3), object, local, pointer_default(unique)]
+interface ID3DDestructionNotifier
+    : IUnknown
+{
+    HRESULT RegisterDestructionCallback(
+        [annotation("_In_")] PFN_DESTRUCTION_CALLBACK callbackFn,
+        [annotation("_In_")] void* pData,
+        [annotation("_Out_")] UINT* pCallbackID
+        );
+    HRESULT UnregisterDestructionCallback(
+        [annotation("_In_")] UINT callbackID
+        );
+};
+
+typedef enum _D3D_INCLUDE_TYPE
+{
+    D3D_INCLUDE_LOCAL,
+    D3D_INCLUDE_SYSTEM,
+
+    D3D10_INCLUDE_LOCAL = D3D_INCLUDE_LOCAL,
+    D3D10_INCLUDE_SYSTEM = D3D_INCLUDE_SYSTEM,
+
+    // force 32-bit size enum
+    D3D_INCLUDE_FORCE_DWORD = 0x7fffffff
+} D3D_INCLUDE_TYPE;
+
+//----------------------------------------------------------------------------
+// ID3DInclude:
+// -------------
+// This interface is intended to be implemented by the application, and can
+// be used by various D3D APIs.  This enables application-specific handling
+// of #include directives in source files.
+//
+// Open()
+//    Opens an include file.  If successful, it should fill in ppData and
+//    pBytes.  The data pointer returned must remain valid until Close is
+//    subsequently called.  The name of the file is encoded in UTF-8 format.
+// Close()
+//    Closes an include file.  If Open was successful, Close is guaranteed
+//    to be called before the API using this interface returns.
+//----------------------------------------------------------------------------
+
+cpp_quote("typedef interface ID3DInclude ID3DInclude;")
+
+cpp_quote("#undef INTERFACE")
+cpp_quote("#define INTERFACE ID3DInclude")
+
+cpp_quote("DECLARE_INTERFACE(ID3DInclude)")
+cpp_quote("{")
+cpp_quote("    STDMETHOD(Open)(THIS_ D3D_INCLUDE_TYPE IncludeType, LPCSTR pFileName, LPCVOID pParentData, LPCVOID *ppData, UINT *pBytes) PURE;")
+cpp_quote("    STDMETHOD(Close)(THIS_ LPCVOID pData) PURE;")
+cpp_quote("};")
+
+cpp_quote("typedef ID3DInclude* LPD3DINCLUDE;")
+
+//----------------------------------------------------------------------------
+//
+// Shader reflection information.
+//
+//----------------------------------------------------------------------------
+
+typedef enum _D3D_SHADER_VARIABLE_CLASS
+{
+    D3D_SVC_SCALAR,
+    D3D_SVC_VECTOR,
+    D3D_SVC_MATRIX_ROWS,
+    D3D_SVC_MATRIX_COLUMNS,
+    D3D_SVC_OBJECT,
+    D3D_SVC_STRUCT,
+    D3D_SVC_INTERFACE_CLASS,
+    D3D_SVC_INTERFACE_POINTER,
+
+    D3D10_SVC_SCALAR = D3D_SVC_SCALAR,
+    D3D10_SVC_VECTOR = D3D_SVC_VECTOR,
+    D3D10_SVC_MATRIX_ROWS = D3D_SVC_MATRIX_ROWS,
+    D3D10_SVC_MATRIX_COLUMNS = D3D_SVC_MATRIX_COLUMNS,
+    D3D10_SVC_OBJECT = D3D_SVC_OBJECT,
+    D3D10_SVC_STRUCT = D3D_SVC_STRUCT,
+
+    D3D11_SVC_INTERFACE_CLASS = D3D_SVC_INTERFACE_CLASS,
+    D3D11_SVC_INTERFACE_POINTER = D3D_SVC_INTERFACE_POINTER,
+
+    // force 32-bit size enum
+    D3D_SVC_FORCE_DWORD = 0x7fffffff
+} D3D_SHADER_VARIABLE_CLASS;
+
+typedef enum _D3D_SHADER_VARIABLE_FLAGS
+{
+    D3D_SVF_USERPACKED = 1,
+    D3D_SVF_USED       = 2,
+
+    D3D_SVF_INTERFACE_POINTER = 4,
+    D3D_SVF_INTERFACE_PARAMETER = 8,
+
+    D3D10_SVF_USERPACKED = D3D_SVF_USERPACKED,
+    D3D10_SVF_USED       = D3D_SVF_USED,
+
+    D3D11_SVF_INTERFACE_POINTER = D3D_SVF_INTERFACE_POINTER,
+    D3D11_SVF_INTERFACE_PARAMETER = D3D_SVF_INTERFACE_PARAMETER,
+
+    // force 32-bit size enum
+    D3D_SVF_FORCE_DWORD = 0x7fffffff
+} D3D_SHADER_VARIABLE_FLAGS;
+
+typedef enum _D3D_SHADER_VARIABLE_TYPE
+{
+    D3D_SVT_VOID = 0,
+    D3D_SVT_BOOL = 1,
+    D3D_SVT_INT = 2,
+    D3D_SVT_FLOAT = 3,
+    D3D_SVT_STRING = 4,
+    D3D_SVT_TEXTURE = 5,
+    D3D_SVT_TEXTURE1D = 6,
+    D3D_SVT_TEXTURE2D = 7,
+    D3D_SVT_TEXTURE3D = 8,
+    D3D_SVT_TEXTURECUBE = 9,
+    D3D_SVT_SAMPLER = 10, 
+    D3D_SVT_SAMPLER1D = 11,
+    D3D_SVT_SAMPLER2D = 12,
+    D3D_SVT_SAMPLER3D = 13,
+    D3D_SVT_SAMPLERCUBE = 14,
+    D3D_SVT_PIXELSHADER = 15,
+    D3D_SVT_VERTEXSHADER = 16,
+    D3D_SVT_PIXELFRAGMENT = 17,
+    D3D_SVT_VERTEXFRAGMENT = 18,
+    D3D_SVT_UINT = 19,
+    D3D_SVT_UINT8 = 20,
+    D3D_SVT_GEOMETRYSHADER = 21,
+    D3D_SVT_RASTERIZER = 22,
+    D3D_SVT_DEPTHSTENCIL = 23,
+    D3D_SVT_BLEND = 24,
+    D3D_SVT_BUFFER = 25,
+    D3D_SVT_CBUFFER = 26,
+    D3D_SVT_TBUFFER = 27,
+    D3D_SVT_TEXTURE1DARRAY = 28,
+    D3D_SVT_TEXTURE2DARRAY = 29,
+    D3D_SVT_RENDERTARGETVIEW = 30,
+    D3D_SVT_DEPTHSTENCILVIEW = 31,
+
+    D3D_SVT_TEXTURE2DMS = 32,
+    D3D_SVT_TEXTURE2DMSARRAY = 33,
+
+    D3D_SVT_TEXTURECUBEARRAY = 34,
+
+    D3D_SVT_HULLSHADER = 35,
+    D3D_SVT_DOMAINSHADER = 36,
+
+    D3D_SVT_INTERFACE_POINTER = 37,
+    D3D_SVT_COMPUTESHADER = 38,
+    
+    D3D_SVT_DOUBLE = 39,
+    
+    D3D_SVT_RWTEXTURE1D = 40,
+    D3D_SVT_RWTEXTURE1DARRAY = 41,
+    D3D_SVT_RWTEXTURE2D = 42,
+    D3D_SVT_RWTEXTURE2DARRAY = 43,
+    D3D_SVT_RWTEXTURE3D = 44,
+    D3D_SVT_RWBUFFER = 45,
+
+    D3D_SVT_BYTEADDRESS_BUFFER = 46,
+    D3D_SVT_RWBYTEADDRESS_BUFFER = 47,
+    D3D_SVT_STRUCTURED_BUFFER = 48,
+    D3D_SVT_RWSTRUCTURED_BUFFER = 49,
+    D3D_SVT_APPEND_STRUCTURED_BUFFER = 50,
+    D3D_SVT_CONSUME_STRUCTURED_BUFFER = 51,
+
+    D3D_SVT_MIN8FLOAT = 52,
+    D3D_SVT_MIN10FLOAT = 53,
+    D3D_SVT_MIN16FLOAT = 54,
+    D3D_SVT_MIN12INT = 55,
+    D3D_SVT_MIN16INT = 56,
+    D3D_SVT_MIN16UINT = 57,
+
+    D3D_SVT_INT16 = 58,
+    D3D_SVT_UINT16 = 59,
+    D3D_SVT_FLOAT16 = 60,
+    D3D_SVT_INT64 = 61,
+    D3D_SVT_UINT64 = 62,
+
+    D3D10_SVT_VOID = D3D_SVT_VOID,
+    D3D10_SVT_BOOL = D3D_SVT_BOOL,
+    D3D10_SVT_INT = D3D_SVT_INT,
+    D3D10_SVT_FLOAT = D3D_SVT_FLOAT,
+    D3D10_SVT_STRING = D3D_SVT_STRING,
+    D3D10_SVT_TEXTURE = D3D_SVT_TEXTURE,
+    D3D10_SVT_TEXTURE1D = D3D_SVT_TEXTURE1D,
+    D3D10_SVT_TEXTURE2D = D3D_SVT_TEXTURE2D,
+    D3D10_SVT_TEXTURE3D = D3D_SVT_TEXTURE3D,
+    D3D10_SVT_TEXTURECUBE = D3D_SVT_TEXTURECUBE,
+    D3D10_SVT_SAMPLER = D3D_SVT_SAMPLER,
+    D3D10_SVT_SAMPLER1D = D3D_SVT_SAMPLER1D,
+    D3D10_SVT_SAMPLER2D = D3D_SVT_SAMPLER2D,
+    D3D10_SVT_SAMPLER3D = D3D_SVT_SAMPLER3D,
+    D3D10_SVT_SAMPLERCUBE = D3D_SVT_SAMPLERCUBE,
+    D3D10_SVT_PIXELSHADER = D3D_SVT_PIXELSHADER,
+    D3D10_SVT_VERTEXSHADER = D3D_SVT_VERTEXSHADER,
+    D3D10_SVT_PIXELFRAGMENT = D3D_SVT_PIXELFRAGMENT,
+    D3D10_SVT_VERTEXFRAGMENT = D3D_SVT_VERTEXFRAGMENT,
+    D3D10_SVT_UINT = D3D_SVT_UINT,
+    D3D10_SVT_UINT8 = D3D_SVT_UINT8,
+    D3D10_SVT_GEOMETRYSHADER = D3D_SVT_GEOMETRYSHADER,
+    D3D10_SVT_RASTERIZER = D3D_SVT_RASTERIZER,
+    D3D10_SVT_DEPTHSTENCIL = D3D_SVT_DEPTHSTENCIL,
+    D3D10_SVT_BLEND = D3D_SVT_BLEND,
+    D3D10_SVT_BUFFER = D3D_SVT_BUFFER,
+    D3D10_SVT_CBUFFER = D3D_SVT_CBUFFER,
+    D3D10_SVT_TBUFFER = D3D_SVT_TBUFFER,
+    D3D10_SVT_TEXTURE1DARRAY = D3D_SVT_TEXTURE1DARRAY,
+    D3D10_SVT_TEXTURE2DARRAY = D3D_SVT_TEXTURE2DARRAY,
+    D3D10_SVT_RENDERTARGETVIEW = D3D_SVT_RENDERTARGETVIEW,
+    D3D10_SVT_DEPTHSTENCILVIEW = D3D_SVT_DEPTHSTENCILVIEW,
+
+    D3D10_SVT_TEXTURE2DMS = D3D_SVT_TEXTURE2DMS,
+    D3D10_SVT_TEXTURE2DMSARRAY = D3D_SVT_TEXTURE2DMSARRAY,
+
+    D3D10_SVT_TEXTURECUBEARRAY = D3D_SVT_TEXTURECUBEARRAY,
+
+    D3D11_SVT_HULLSHADER = D3D_SVT_HULLSHADER,
+    D3D11_SVT_DOMAINSHADER = D3D_SVT_DOMAINSHADER,
+
+    D3D11_SVT_INTERFACE_POINTER = D3D_SVT_INTERFACE_POINTER,
+    D3D11_SVT_COMPUTESHADER = D3D_SVT_COMPUTESHADER,
+
+    D3D11_SVT_DOUBLE = D3D_SVT_DOUBLE,
+    
+    D3D11_SVT_RWTEXTURE1D = D3D_SVT_RWTEXTURE1D,
+    D3D11_SVT_RWTEXTURE1DARRAY = D3D_SVT_RWTEXTURE1DARRAY,
+    D3D11_SVT_RWTEXTURE2D = D3D_SVT_RWTEXTURE2D,
+    D3D11_SVT_RWTEXTURE2DARRAY = D3D_SVT_RWTEXTURE2DARRAY,
+    D3D11_SVT_RWTEXTURE3D = D3D_SVT_RWTEXTURE3D,
+    D3D11_SVT_RWBUFFER = D3D_SVT_RWBUFFER,
+    
+    D3D11_SVT_BYTEADDRESS_BUFFER = D3D_SVT_BYTEADDRESS_BUFFER,
+    D3D11_SVT_RWBYTEADDRESS_BUFFER = D3D_SVT_RWBYTEADDRESS_BUFFER,
+    D3D11_SVT_STRUCTURED_BUFFER = D3D_SVT_STRUCTURED_BUFFER,
+    D3D11_SVT_RWSTRUCTURED_BUFFER = D3D_SVT_RWSTRUCTURED_BUFFER,
+    D3D11_SVT_APPEND_STRUCTURED_BUFFER = D3D_SVT_APPEND_STRUCTURED_BUFFER,
+    D3D11_SVT_CONSUME_STRUCTURED_BUFFER = D3D_SVT_CONSUME_STRUCTURED_BUFFER,
+
+    // force 32-bit size enum
+    D3D_SVT_FORCE_DWORD = 0x7fffffff
+} D3D_SHADER_VARIABLE_TYPE;
+
+typedef enum _D3D_SHADER_INPUT_FLAGS
+{
+    D3D_SIF_USERPACKED          = 0x01,
+    D3D_SIF_COMPARISON_SAMPLER  = 0x02, // is this a comparison sampler?
+    D3D_SIF_TEXTURE_COMPONENT_0 = 0x04, // this 2-bit value encodes c - 1, where c
+    D3D_SIF_TEXTURE_COMPONENT_1 = 0x08, // is the number of components in the texture
+    D3D_SIF_TEXTURE_COMPONENTS  = 0x0c,
+    D3D_SIF_UNUSED              = 0x10,
+
+    D3D10_SIF_USERPACKED = D3D_SIF_USERPACKED,
+    D3D10_SIF_COMPARISON_SAMPLER = D3D_SIF_COMPARISON_SAMPLER,
+    D3D10_SIF_TEXTURE_COMPONENT_0 = D3D_SIF_TEXTURE_COMPONENT_0,
+    D3D10_SIF_TEXTURE_COMPONENT_1 = D3D_SIF_TEXTURE_COMPONENT_1,
+    D3D10_SIF_TEXTURE_COMPONENTS = D3D_SIF_TEXTURE_COMPONENTS,
+
+    // force 32-bit size enum
+    D3D_SIF_FORCE_DWORD = 0x7fffffff
+} D3D_SHADER_INPUT_FLAGS;
+
+typedef enum _D3D_SHADER_INPUT_TYPE
+{
+    D3D_SIT_CBUFFER,
+    D3D_SIT_TBUFFER,
+    D3D_SIT_TEXTURE,
+    D3D_SIT_SAMPLER,
+    D3D_SIT_UAV_RWTYPED,
+    D3D_SIT_STRUCTURED,
+    D3D_SIT_UAV_RWSTRUCTURED,
+    D3D_SIT_BYTEADDRESS,
+    D3D_SIT_UAV_RWBYTEADDRESS,
+    D3D_SIT_UAV_APPEND_STRUCTURED,
+    D3D_SIT_UAV_CONSUME_STRUCTURED,
+    D3D_SIT_UAV_RWSTRUCTURED_WITH_COUNTER,
+    D3D_SIT_RTACCELERATIONSTRUCTURE,
+    D3D_SIT_UAV_FEEDBACKTEXTURE,
+
+    D3D10_SIT_CBUFFER = D3D_SIT_CBUFFER,
+    D3D10_SIT_TBUFFER = D3D_SIT_TBUFFER,
+    D3D10_SIT_TEXTURE = D3D_SIT_TEXTURE,
+    D3D10_SIT_SAMPLER = D3D_SIT_SAMPLER,
+
+    D3D11_SIT_UAV_RWTYPED = D3D_SIT_UAV_RWTYPED,
+    D3D11_SIT_STRUCTURED = D3D_SIT_STRUCTURED,
+    D3D11_SIT_UAV_RWSTRUCTURED = D3D_SIT_UAV_RWSTRUCTURED,
+    D3D11_SIT_BYTEADDRESS = D3D_SIT_BYTEADDRESS,
+    D3D11_SIT_UAV_RWBYTEADDRESS = D3D_SIT_UAV_RWBYTEADDRESS,
+    D3D11_SIT_UAV_APPEND_STRUCTURED = D3D_SIT_UAV_APPEND_STRUCTURED,
+    D3D11_SIT_UAV_CONSUME_STRUCTURED = D3D_SIT_UAV_CONSUME_STRUCTURED,
+    D3D11_SIT_UAV_RWSTRUCTURED_WITH_COUNTER = D3D_SIT_UAV_RWSTRUCTURED_WITH_COUNTER,
+} D3D_SHADER_INPUT_TYPE;
+
+typedef enum _D3D_SHADER_CBUFFER_FLAGS
+{
+    D3D_CBF_USERPACKED = 1,
+
+    D3D10_CBF_USERPACKED = D3D_CBF_USERPACKED,
+
+    // force 32-bit size enum
+    D3D_CBF_FORCE_DWORD = 0x7fffffff
+} D3D_SHADER_CBUFFER_FLAGS;
+
+typedef enum _D3D_CBUFFER_TYPE
+{
+    D3D_CT_CBUFFER,
+    D3D_CT_TBUFFER,
+    D3D_CT_INTERFACE_POINTERS,
+    D3D_CT_RESOURCE_BIND_INFO,
+
+    D3D10_CT_CBUFFER = D3D_CT_CBUFFER,
+    D3D10_CT_TBUFFER = D3D_CT_TBUFFER,
+
+    D3D11_CT_CBUFFER = D3D_CT_CBUFFER,
+    D3D11_CT_TBUFFER = D3D_CT_TBUFFER,
+    D3D11_CT_INTERFACE_POINTERS = D3D_CT_INTERFACE_POINTERS,
+    D3D11_CT_RESOURCE_BIND_INFO = D3D_CT_RESOURCE_BIND_INFO,
+}  D3D_CBUFFER_TYPE;
+
+typedef enum D3D_NAME
+{
+    D3D_NAME_UNDEFINED = 0,
+
+    // Names meaningful to both HLSL and hardware
+    D3D_NAME_POSITION = 1,
+    D3D_NAME_CLIP_DISTANCE = 2,
+    D3D_NAME_CULL_DISTANCE = 3,
+    D3D_NAME_RENDER_TARGET_ARRAY_INDEX = 4,
+    D3D_NAME_VIEWPORT_ARRAY_INDEX = 5,
+    D3D_NAME_VERTEX_ID = 6,
+    D3D_NAME_PRIMITIVE_ID = 7,
+    D3D_NAME_INSTANCE_ID = 8,
+    D3D_NAME_IS_FRONT_FACE = 9,
+    D3D_NAME_SAMPLE_INDEX = 10,
+    D3D_NAME_FINAL_QUAD_EDGE_TESSFACTOR = 11, 
+    D3D_NAME_FINAL_QUAD_INSIDE_TESSFACTOR = 12, 
+    D3D_NAME_FINAL_TRI_EDGE_TESSFACTOR = 13, 
+    D3D_NAME_FINAL_TRI_INSIDE_TESSFACTOR = 14, 
+    D3D_NAME_FINAL_LINE_DETAIL_TESSFACTOR = 15,
+    D3D_NAME_FINAL_LINE_DENSITY_TESSFACTOR = 16,
+    D3D_NAME_BARYCENTRICS = 23,
+    D3D_NAME_SHADINGRATE = 24,
+    D3D_NAME_CULLPRIMITIVE = 25,
+
+    // Names meaningful to HLSL only
+    D3D_NAME_TARGET = 64,
+    D3D_NAME_DEPTH = 65,
+    D3D_NAME_COVERAGE = 66,
+    D3D_NAME_DEPTH_GREATER_EQUAL = 67,
+    D3D_NAME_DEPTH_LESS_EQUAL = 68,
+    D3D_NAME_STENCIL_REF = 69,
+    D3D_NAME_INNER_COVERAGE = 70,
+
+    D3D10_NAME_UNDEFINED = D3D_NAME_UNDEFINED,
+    D3D10_NAME_POSITION = D3D_NAME_POSITION,
+    D3D10_NAME_CLIP_DISTANCE = D3D_NAME_CLIP_DISTANCE,
+    D3D10_NAME_CULL_DISTANCE = D3D_NAME_CULL_DISTANCE,
+    D3D10_NAME_RENDER_TARGET_ARRAY_INDEX = D3D_NAME_RENDER_TARGET_ARRAY_INDEX,
+    D3D10_NAME_VIEWPORT_ARRAY_INDEX = D3D_NAME_VIEWPORT_ARRAY_INDEX,
+    D3D10_NAME_VERTEX_ID = D3D_NAME_VERTEX_ID,
+    D3D10_NAME_PRIMITIVE_ID = D3D_NAME_PRIMITIVE_ID,
+    D3D10_NAME_INSTANCE_ID = D3D_NAME_INSTANCE_ID,
+    D3D10_NAME_IS_FRONT_FACE = D3D_NAME_IS_FRONT_FACE,
+    D3D10_NAME_SAMPLE_INDEX = D3D_NAME_SAMPLE_INDEX,
+    D3D10_NAME_TARGET = D3D_NAME_TARGET,
+    D3D10_NAME_DEPTH = D3D_NAME_DEPTH,
+    D3D10_NAME_COVERAGE = D3D_NAME_COVERAGE,
+
+    D3D11_NAME_FINAL_QUAD_EDGE_TESSFACTOR = D3D_NAME_FINAL_QUAD_EDGE_TESSFACTOR, 
+    D3D11_NAME_FINAL_QUAD_INSIDE_TESSFACTOR = D3D_NAME_FINAL_QUAD_INSIDE_TESSFACTOR, 
+    D3D11_NAME_FINAL_TRI_EDGE_TESSFACTOR = D3D_NAME_FINAL_TRI_EDGE_TESSFACTOR, 
+    D3D11_NAME_FINAL_TRI_INSIDE_TESSFACTOR = D3D_NAME_FINAL_TRI_INSIDE_TESSFACTOR, 
+    D3D11_NAME_FINAL_LINE_DETAIL_TESSFACTOR = D3D_NAME_FINAL_LINE_DETAIL_TESSFACTOR,
+    D3D11_NAME_FINAL_LINE_DENSITY_TESSFACTOR = D3D_NAME_FINAL_LINE_DENSITY_TESSFACTOR,
+    D3D11_NAME_DEPTH_GREATER_EQUAL = D3D_NAME_DEPTH_GREATER_EQUAL,
+    D3D11_NAME_DEPTH_LESS_EQUAL = D3D_NAME_DEPTH_LESS_EQUAL,
+
+    D3D11_NAME_STENCIL_REF = D3D_NAME_STENCIL_REF,
+    D3D11_NAME_INNER_COVERAGE = D3D_NAME_INNER_COVERAGE,
+
+    D3D12_NAME_BARYCENTRICS = D3D_NAME_BARYCENTRICS,
+    D3D12_NAME_SHADINGRATE = D3D_NAME_SHADINGRATE,
+    D3D12_NAME_CULLPRIMITIVE = D3D_NAME_CULLPRIMITIVE,
+} D3D_NAME;
+
+typedef enum D3D_RESOURCE_RETURN_TYPE
+{
+    D3D_RETURN_TYPE_UNORM = 1,
+    D3D_RETURN_TYPE_SNORM = 2,
+    D3D_RETURN_TYPE_SINT = 3,
+    D3D_RETURN_TYPE_UINT = 4,
+    D3D_RETURN_TYPE_FLOAT = 5,
+    D3D_RETURN_TYPE_MIXED = 6,
+    D3D_RETURN_TYPE_DOUBLE = 7,
+    D3D_RETURN_TYPE_CONTINUED = 8,
+
+    D3D10_RETURN_TYPE_UNORM = D3D_RETURN_TYPE_UNORM,
+    D3D10_RETURN_TYPE_SNORM = D3D_RETURN_TYPE_SNORM,
+    D3D10_RETURN_TYPE_SINT = D3D_RETURN_TYPE_SINT,
+    D3D10_RETURN_TYPE_UINT = D3D_RETURN_TYPE_UINT,
+    D3D10_RETURN_TYPE_FLOAT = D3D_RETURN_TYPE_FLOAT,
+    D3D10_RETURN_TYPE_MIXED = D3D_RETURN_TYPE_MIXED,
+
+    D3D11_RETURN_TYPE_UNORM = D3D_RETURN_TYPE_UNORM,
+    D3D11_RETURN_TYPE_SNORM = D3D_RETURN_TYPE_SNORM,
+    D3D11_RETURN_TYPE_SINT = D3D_RETURN_TYPE_SINT,
+    D3D11_RETURN_TYPE_UINT = D3D_RETURN_TYPE_UINT,
+    D3D11_RETURN_TYPE_FLOAT = D3D_RETURN_TYPE_FLOAT,
+    D3D11_RETURN_TYPE_MIXED = D3D_RETURN_TYPE_MIXED,
+    D3D11_RETURN_TYPE_DOUBLE = D3D_RETURN_TYPE_DOUBLE,
+    D3D11_RETURN_TYPE_CONTINUED = D3D_RETURN_TYPE_CONTINUED,
+} D3D_RESOURCE_RETURN_TYPE;
+
+typedef enum D3D_REGISTER_COMPONENT_TYPE
+{
+    D3D_REGISTER_COMPONENT_UNKNOWN = 0,
+    D3D_REGISTER_COMPONENT_UINT32 = 1,
+    D3D_REGISTER_COMPONENT_SINT32 = 2,
+    D3D_REGISTER_COMPONENT_FLOAT32 = 3,
+
+    D3D10_REGISTER_COMPONENT_UNKNOWN = D3D_REGISTER_COMPONENT_UNKNOWN,
+    D3D10_REGISTER_COMPONENT_UINT32 = D3D_REGISTER_COMPONENT_UINT32,
+    D3D10_REGISTER_COMPONENT_SINT32 = D3D_REGISTER_COMPONENT_SINT32,
+    D3D10_REGISTER_COMPONENT_FLOAT32 = D3D_REGISTER_COMPONENT_FLOAT32,
+} D3D_REGISTER_COMPONENT_TYPE;
+
+typedef enum D3D_TESSELLATOR_DOMAIN
+{
+    D3D_TESSELLATOR_DOMAIN_UNDEFINED = 0,
+    D3D_TESSELLATOR_DOMAIN_ISOLINE = 1,
+    D3D_TESSELLATOR_DOMAIN_TRI = 2,
+    D3D_TESSELLATOR_DOMAIN_QUAD = 3,
+
+    D3D11_TESSELLATOR_DOMAIN_UNDEFINED = D3D_TESSELLATOR_DOMAIN_UNDEFINED,
+    D3D11_TESSELLATOR_DOMAIN_ISOLINE = D3D_TESSELLATOR_DOMAIN_ISOLINE,
+    D3D11_TESSELLATOR_DOMAIN_TRI = D3D_TESSELLATOR_DOMAIN_TRI,
+    D3D11_TESSELLATOR_DOMAIN_QUAD = D3D_TESSELLATOR_DOMAIN_QUAD,
+} D3D_TESSELLATOR_DOMAIN;
+
+typedef enum D3D_TESSELLATOR_PARTITIONING
+{
+    D3D_TESSELLATOR_PARTITIONING_UNDEFINED = 0,
+    D3D_TESSELLATOR_PARTITIONING_INTEGER = 1,
+    D3D_TESSELLATOR_PARTITIONING_POW2 = 2,
+    D3D_TESSELLATOR_PARTITIONING_FRACTIONAL_ODD = 3,
+    D3D_TESSELLATOR_PARTITIONING_FRACTIONAL_EVEN = 4,
+
+    D3D11_TESSELLATOR_PARTITIONING_UNDEFINED = D3D_TESSELLATOR_PARTITIONING_UNDEFINED,
+    D3D11_TESSELLATOR_PARTITIONING_INTEGER = D3D_TESSELLATOR_PARTITIONING_INTEGER,
+    D3D11_TESSELLATOR_PARTITIONING_POW2 = D3D_TESSELLATOR_PARTITIONING_POW2,
+    D3D11_TESSELLATOR_PARTITIONING_FRACTIONAL_ODD = D3D_TESSELLATOR_PARTITIONING_FRACTIONAL_ODD,
+    D3D11_TESSELLATOR_PARTITIONING_FRACTIONAL_EVEN = D3D_TESSELLATOR_PARTITIONING_FRACTIONAL_EVEN,
+} D3D_TESSELLATOR_PARTITIONING;
+
+typedef enum D3D_TESSELLATOR_OUTPUT_PRIMITIVE
+{
+    D3D_TESSELLATOR_OUTPUT_UNDEFINED = 0,
+    D3D_TESSELLATOR_OUTPUT_POINT = 1,
+    D3D_TESSELLATOR_OUTPUT_LINE = 2,
+    D3D_TESSELLATOR_OUTPUT_TRIANGLE_CW = 3,
+    D3D_TESSELLATOR_OUTPUT_TRIANGLE_CCW = 4,
+
+    D3D11_TESSELLATOR_OUTPUT_UNDEFINED = D3D_TESSELLATOR_OUTPUT_UNDEFINED,
+    D3D11_TESSELLATOR_OUTPUT_POINT = D3D_TESSELLATOR_OUTPUT_POINT,
+    D3D11_TESSELLATOR_OUTPUT_LINE = D3D_TESSELLATOR_OUTPUT_LINE,
+    D3D11_TESSELLATOR_OUTPUT_TRIANGLE_CW = D3D_TESSELLATOR_OUTPUT_TRIANGLE_CW,
+    D3D11_TESSELLATOR_OUTPUT_TRIANGLE_CCW = D3D_TESSELLATOR_OUTPUT_TRIANGLE_CCW,
+} D3D_TESSELLATOR_OUTPUT_PRIMITIVE;
+
+typedef enum D3D_MIN_PRECISION
+{
+    D3D_MIN_PRECISION_DEFAULT    = 0, // Default precision for the shader model
+    D3D_MIN_PRECISION_FLOAT_16   = 1, // Min 16 bit/component float
+    D3D_MIN_PRECISION_FLOAT_2_8  = 2, // Min 10(2.8)bit/comp. float
+    D3D_MIN_PRECISION_RESERVED   = 3, // Reserved for future use
+    D3D_MIN_PRECISION_SINT_16    = 4, // Min 16 bit/comp. signed integer
+    D3D_MIN_PRECISION_UINT_16    = 5, // Min 16 bit/comp. unsigned integer
+
+    // These values are abstractions of width only for use in situations
+    // where a general width is needed instead of specific types.  They
+    // will never be used in shader operands.
+    D3D_MIN_PRECISION_ANY_16     = 0xf0,
+    D3D_MIN_PRECISION_ANY_10     = 0xf1,
+} D3D_MIN_PRECISION;
+
+typedef enum D3D_INTERPOLATION_MODE
+{
+    D3D_INTERPOLATION_UNDEFINED = 0,
+    D3D_INTERPOLATION_CONSTANT = 1,
+    D3D_INTERPOLATION_LINEAR = 2,
+    D3D_INTERPOLATION_LINEAR_CENTROID = 3,
+    D3D_INTERPOLATION_LINEAR_NOPERSPECTIVE = 4,
+    D3D_INTERPOLATION_LINEAR_NOPERSPECTIVE_CENTROID = 5,
+    D3D_INTERPOLATION_LINEAR_SAMPLE = 6,
+    D3D_INTERPOLATION_LINEAR_NOPERSPECTIVE_SAMPLE = 7,
+} D3D_INTERPOLATION_MODE;
+
+// Parameter flags.
+typedef enum _D3D_PARAMETER_FLAGS
+{
+    D3D_PF_NONE               = 0x00000000,
+    D3D_PF_IN                 = 0x00000001,
+    D3D_PF_OUT                = 0x00000002,
+    D3D_PF_FORCE_DWORD        = 0x7fffffff
+} D3D_PARAMETER_FLAGS;
+
+// Format Layout Properties
+typedef enum D3D_FORMAT_LAYOUT
+{
+    D3DFL_STANDARD = 0, // standard layout
+    D3DFL_CUSTOM = -1  // custom layout
+    // Note, 1 bit allocated for this in FORMAT_DETAIL below. If you add fields here, add bits...
+    // NOTE SIGNED VALUES ARE USED SINCE COMPILER MAKES ENUMS SIGNED, AND BITFIELDS ARE SIGN EXTENDED ON READ
+} D3D_FORMAT_LAYOUT;
+
+typedef enum D3D_FORMAT_TYPE_LEVEL
+{
+    D3DFTL_NO_TYPE = 0,
+    D3DFTL_PARTIAL_TYPE = -2,
+    D3DFTL_FULL_TYPE = -1,
+    // Note, 2 bits allocated for this in FORMAT_DETAIL below. If you add fields here, add bits...
+    // NOTE SIGNED VALUES ARE USED SINCE COMPILER MAKES ENUMS SIGNED, AND BITFIELDS ARE SIGN EXTENDED ON READ
+} D3D_FORMAT_TYPE_LEVEL;
+
+typedef enum D3D_FORMAT_COMPONENT_NAME
+{
+    D3DFCN_R = -4,
+    D3DFCN_G = -3,
+    D3DFCN_B = -2,
+    D3DFCN_A = -1,
+    D3DFCN_D = 0,
+    D3DFCN_S = 1,
+    D3DFCN_X = 2,
+    // Note, 3 bits allocated for this in FORMAT_DETAIL below. If you add fields here, add bits...
+    // NOTE SIGNED VALUES ARE USED SINCE COMPILER MAKES ENUMS SIGNED, AND BITFIELDS ARE SIGN EXTENDED ON READ
+} D3D_FORMAT_COMPONENT_NAME;
+
+typedef enum D3D_FORMAT_COMPONENT_INTERPRETATION
+{
+    D3DFCI_TYPELESS = 0,
+    D3DFCI_FLOAT = -4,
+    D3DFCI_SNORM = -3,
+    D3DFCI_UNORM = -2,
+    D3DFCI_SINT = -1,
+    D3DFCI_UINT = 1,
+    D3DFCI_UNORM_SRGB = 2,
+    D3DFCI_BIASED_FIXED_2_8 = 3,
+    // Note, 3 bits allocated for this in FORMAT_DETAIL below. If you add fields here, add bits...
+    // NOTE SIGNED VALUES ARE USED SINCE COMPILER MAKES ENUMS SIGNED, AND BITFIELDS ARE SIGN EXTENDED ON READ
+} D3D_FORMAT_COMPONENT_INTERPRETATION;
+
+// Well-Known Private Data IDs (WKPDID_*):
+
+// WKPDID_D3DDebugObjectName provides a unique name to objects in order to assist the developer during debugging.
+//
+// const char c_szName[] = "texture.jpg";
+// pObject->SetPrivateData( WKPDID_D3DDebugObjectName, sizeof( c_szName ) - 1, c_szName );
+cpp_quote("DEFINE_GUID(WKPDID_D3DDebugObjectName,0x429b8c22,0x9188,0x4b0c,0x87,0x42,0xac,0xb0,0xbf,0x85,0xc2,0x00);")
+cpp_quote("DEFINE_GUID(WKPDID_D3DDebugObjectNameW,0x4cca5fd8,0x921f,0x42c8,0x85,0x66,0x70,0xca,0xf2,0xa9,0xb7,0x41);")
+cpp_quote("DEFINE_GUID(WKPDID_CommentStringW,0xd0149dc0,0x90e8,0x4ec8,0x81, 0x44, 0xe9, 0x00, 0xad, 0x26, 0x6b, 0xb2);")
+cpp_quote("DEFINE_GUID(WKPDID_D3D12UniqueObjectId, 0x1b39de15, 0xec04, 0x4bae, 0xba, 0x4d, 0x8c, 0xef, 0x79, 0xfc, 0x04, 0xc1);")
+
+cpp_quote("#define D3D_SET_OBJECT_NAME_N_A(pObject, Chars, pName) (pObject)->SetPrivateData(WKPDID_D3DDebugObjectName, Chars, pName)")
+cpp_quote("#define D3D_SET_OBJECT_NAME_A(pObject, pName) D3D_SET_OBJECT_NAME_N_A(pObject, lstrlenA(pName), pName)")
+cpp_quote("#define D3D_SET_OBJECT_NAME_N_W(pObject, Chars, pName) (pObject)->SetPrivateData(WKPDID_D3DDebugObjectNameW, Chars*2, pName)")
+cpp_quote("#define D3D_SET_OBJECT_NAME_W(pObject, pName) D3D_SET_OBJECT_NAME_N_W(pObject, wcslen(pName), pName)")
+
+cpp_quote("#define D3D_COMPONENT_MASK_X   1")
+cpp_quote("#define D3D_COMPONENT_MASK_Y   2")
+cpp_quote("#define D3D_COMPONENT_MASK_Z   4")
+cpp_quote("#define D3D_COMPONENT_MASK_W   8")
+
+cpp_quote("DEFINE_GUID(D3D_TEXTURE_LAYOUT_ROW_MAJOR,0xb5dc234f,0x72bb,0x4bec,0x97,0x05,0x8c,0xf2,0x58,0xdf,0x6b,0x6c);") // Feature_D3D1XDisplayable
+cpp_quote("DEFINE_GUID(D3D_TEXTURE_LAYOUT_64KB_STANDARD_SWIZZLE,0x4c0f29e3,0x3f5f,0x4d35,0x84,0xc9,0xbc,0x09,0x83,0xb6,0x2c,0x28);") // Feature_D3D1XDisplayable
+

EscapeTheBackroomsGUiTest/vcpkg_Out/include/directx/dxcore.h

@@ -0,0 +1,41 @@
+/************************************************************
+*                                                           *
+* Copyright (c) Microsoft Corporation.                      *
+* Licensed under the MIT license.                           *
+*                                                           *
+************************************************************/
+
+#ifndef _DXCOREEXTMODULE_H_
+#define _DXCOREEXTMODULE_H_
+
+#include <winapifamily.h>
+#include "dxcore_interface.h"
+
+#pragma region Application Family or OneCore Family
+#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP | WINAPI_PARTITION_SYSTEM)
+
+#if (_WIN32_WINNT >= _WIN32_WINNT_WIN10)
+
+STDAPI
+DXCoreCreateAdapterFactory(
+    REFIID riid,
+    _COM_Outptr_ void** ppvFactory
+);
+
+template <class T>
+HRESULT
+DXCoreCreateAdapterFactory(
+    _COM_Outptr_ T** ppvFactory
+)
+{
+    return DXCoreCreateAdapterFactory(IID_PPV_ARGS(ppvFactory));
+}
+
+#endif // (_WIN32_WINNT >= _WIN32_WINNT_WIN10)
+
+#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP | WINAPI_PARTITION_SYSTEM) */
+#pragma endregion
+
+#endif // _DXCOREEXTMODULE_H_
+
+

EscapeTheBackroomsGUiTest/vcpkg_Out/include/directx/dxcore_interface.h

@@ -0,0 +1,316 @@
+//
+// DXCore Interface
+// Copyright (C) Microsoft Corporation.
+// Licensed under the MIT license.
+//
+
+#ifndef __dxcore_interface_h__
+#define __dxcore_interface_h__
+
+#ifndef COM_NO_WINDOWS_H
+#include "windows.h"
+#include "ole2.h"
+#endif /*COM_NO_WINDOWS_H*/
+
+#include <stdint.h>
+
+#ifdef __cplusplus
+
+#define _FACDXCORE    0x880
+#define MAKE_DXCORE_HRESULT( code )     MAKE_HRESULT( 1, _FACDXCORE, code )
+
+enum class DXCoreAdapterProperty : uint32_t
+{
+    InstanceLuid = 0,
+    DriverVersion = 1,
+    DriverDescription = 2,
+    HardwareID = 3, // Use HardwareIDParts instead, if available.
+    KmdModelVersion = 4,
+    ComputePreemptionGranularity = 5,
+    GraphicsPreemptionGranularity = 6,
+    DedicatedAdapterMemory = 7,
+    DedicatedSystemMemory = 8,
+    SharedSystemMemory = 9,
+    AcgCompatible = 10,
+    IsHardware = 11,
+    IsIntegrated = 12,
+    IsDetachable = 13,
+    HardwareIDParts = 14
+};
+
+enum class DXCoreAdapterState : uint32_t
+{
+    IsDriverUpdateInProgress = 0,
+    AdapterMemoryBudget = 1
+};
+
+enum class DXCoreSegmentGroup : uint32_t
+{
+    Local = 0,
+    NonLocal = 1
+};
+
+enum class DXCoreNotificationType : uint32_t
+{
+    AdapterListStale = 0,
+    AdapterNoLongerValid = 1,
+    AdapterBudgetChange = 2,
+    AdapterHardwareContentProtectionTeardown = 3
+};
+
+enum class DXCoreAdapterPreference : uint32_t
+{
+    Hardware = 0,
+    MinimumPower = 1,
+    HighPerformance = 2
+};
+
+struct DXCoreHardwareID
+{
+    uint32_t vendorID;
+    uint32_t deviceID;
+    uint32_t subSysID;
+    uint32_t revision;
+};
+
+struct DXCoreHardwareIDParts
+{
+    uint32_t vendorID;
+    uint32_t deviceID;
+    uint32_t subSystemID;
+    uint32_t subVendorID;
+    uint32_t revisionID;
+};
+
+struct DXCoreAdapterMemoryBudgetNodeSegmentGroup
+{
+    uint32_t nodeIndex;
+    DXCoreSegmentGroup segmentGroup;
+};
+
+struct DXCoreAdapterMemoryBudget
+{
+    uint64_t budget;
+    uint64_t currentUsage;
+    uint64_t availableForReservation;
+    uint64_t currentReservation;
+};
+
+typedef void (STDMETHODCALLTYPE *PFN_DXCORE_NOTIFICATION_CALLBACK)(
+    DXCoreNotificationType notificationType,
+    _In_ IUnknown *object,
+    _In_opt_ void *context);
+
+static_assert(sizeof(bool) == 1, "bool assumed as one byte");
+
+DEFINE_GUID(IID_IDXCoreAdapterFactory, 0x78ee5945, 0xc36e, 0x4b13, 0xa6, 0x69, 0x00, 0x5d, 0xd1, 0x1c, 0x0f, 0x06);
+DEFINE_GUID(IID_IDXCoreAdapterList, 0x526c7776, 0x40e9, 0x459b, 0xb7, 0x11, 0xf3, 0x2a, 0xd7, 0x6d, 0xfc, 0x28);
+DEFINE_GUID(IID_IDXCoreAdapter, 0xf0db4c7f, 0xfe5a, 0x42a2, 0xbd, 0x62, 0xf2, 0xa6, 0xcf, 0x6f, 0xc8, 0x3e);
+DEFINE_GUID(DXCORE_ADAPTER_ATTRIBUTE_D3D11_GRAPHICS, 0x8c47866b, 0x7583, 0x450d, 0xf0, 0xf0, 0x6b, 0xad, 0xa8, 0x95, 0xaf, 0x4b);
+DEFINE_GUID(DXCORE_ADAPTER_ATTRIBUTE_D3D12_GRAPHICS, 0x0c9ece4d, 0x2f6e, 0x4f01, 0x8c, 0x96, 0xe8, 0x9e, 0x33, 0x1b, 0x47, 0xb1);
+DEFINE_GUID(DXCORE_ADAPTER_ATTRIBUTE_D3D12_CORE_COMPUTE, 0x248e2800, 0xa793, 0x4724, 0xab, 0xaa, 0x23, 0xa6, 0xde, 0x1b, 0xe0, 0x90);
+
+/* interface IDXCoreAdapter */
+MIDL_INTERFACE("f0db4c7f-fe5a-42a2-bd62-f2a6cf6fc83e")
+IDXCoreAdapter : public IUnknown
+{
+public:
+    virtual bool STDMETHODCALLTYPE IsValid() = 0;
+
+    virtual bool STDMETHODCALLTYPE IsAttributeSupported( 
+        REFGUID attributeGUID) = 0;
+
+    virtual bool STDMETHODCALLTYPE IsPropertySupported( 
+        DXCoreAdapterProperty property) = 0;
+
+    virtual HRESULT STDMETHODCALLTYPE GetProperty( 
+        DXCoreAdapterProperty property,
+        size_t bufferSize,
+        _Out_writes_bytes_(bufferSize)  void *propertyData) = 0;
+
+    template <class T>
+    HRESULT GetProperty( 
+        DXCoreAdapterProperty property,
+        _Out_writes_bytes_(sizeof(T))  T *propertyData)
+    {
+        return GetProperty(property,
+                           sizeof(T),
+                           (void*)propertyData);
+    }
+
+    virtual HRESULT STDMETHODCALLTYPE GetPropertySize( 
+        DXCoreAdapterProperty property,
+        _Out_ size_t *bufferSize) = 0;
+
+    virtual bool STDMETHODCALLTYPE IsQueryStateSupported( 
+        DXCoreAdapterState property) = 0;
+
+    virtual HRESULT STDMETHODCALLTYPE QueryState( 
+        DXCoreAdapterState state,
+        size_t inputStateDetailsSize,
+        _In_reads_bytes_opt_(inputStateDetailsSize) const void *inputStateDetails,
+        size_t outputBufferSize,
+        _Out_writes_bytes_(outputBufferSize) void *outputBuffer) = 0;
+
+    template <class T1, class T2>
+    HRESULT QueryState( 
+        DXCoreAdapterState state,
+        _In_reads_bytes_opt_(sizeof(T1)) const T1 *inputStateDetails,
+        _Out_writes_bytes_(sizeof(T2)) T2 *outputBuffer)
+    {
+        return QueryState(state,
+                          sizeof(T1),
+                          (const void*)inputStateDetails,
+                          sizeof(T2),
+                          (void*)outputBuffer);
+    }
+
+    template <class T>
+    HRESULT QueryState( 
+        DXCoreAdapterState state,
+        _Out_writes_bytes_(sizeof(T)) T *outputBuffer)
+    {
+        return QueryState(state,
+                          0,
+                          nullptr,
+                          sizeof(T),
+                          (void*)outputBuffer);
+    }
+
+    virtual bool STDMETHODCALLTYPE IsSetStateSupported( 
+        DXCoreAdapterState property) = 0;
+
+    virtual HRESULT STDMETHODCALLTYPE SetState( 
+        DXCoreAdapterState state,
+        size_t inputStateDetailsSize,
+        _In_reads_bytes_opt_(inputStateDetailsSize) const void *inputStateDetails,
+        size_t inputDataSize,
+        _In_reads_bytes_(inputDataSize) const void *inputData) = 0;
+
+    template <class T1, class T2>
+    HRESULT SetState( 
+        DXCoreAdapterState state,
+        const T1 *inputStateDetails,
+        const T2 *inputData)
+    {
+        return SetState(state,
+                        sizeof(T1),
+                        (const void*)inputStateDetails,
+                        sizeof(T2),
+                        (const void*)inputData);
+    }
+
+    virtual HRESULT STDMETHODCALLTYPE GetFactory(
+        REFIID riid,
+        _COM_Outptr_ void** ppvFactory
+    ) = 0;
+
+    template <class T>
+    HRESULT GetFactory(
+        _COM_Outptr_ T** ppvFactory
+    )
+    {
+        return GetFactory(IID_PPV_ARGS(ppvFactory));
+    }
+};
+
+/* interface IDXCoreAdapterList */
+MIDL_INTERFACE("526c7776-40e9-459b-b711-f32ad76dfc28")
+IDXCoreAdapterList : public IUnknown
+{
+public:
+    virtual HRESULT STDMETHODCALLTYPE GetAdapter( 
+        uint32_t index,
+        REFIID riid,
+        _COM_Outptr_ void **ppvAdapter) = 0;
+
+    template<class T>
+    HRESULT STDMETHODCALLTYPE GetAdapter( 
+        uint32_t index,
+        _COM_Outptr_ T **ppvAdapter)
+    {
+        return GetAdapter(index,
+                          IID_PPV_ARGS(ppvAdapter));
+    }
+
+    virtual uint32_t STDMETHODCALLTYPE GetAdapterCount() = 0;
+
+    virtual bool STDMETHODCALLTYPE IsStale() = 0;
+
+    virtual HRESULT STDMETHODCALLTYPE GetFactory(
+        REFIID riid,
+        _COM_Outptr_ void** ppvFactory
+    ) = 0;
+
+    template <class T>
+    HRESULT GetFactory(
+        _COM_Outptr_ T** ppvFactory
+    )
+    {
+        return GetFactory(IID_PPV_ARGS(ppvFactory));
+    }
+
+    virtual HRESULT STDMETHODCALLTYPE Sort(
+        uint32_t numPreferences,
+        _In_reads_(numPreferences) const DXCoreAdapterPreference* preferences) = 0;
+
+    virtual bool STDMETHODCALLTYPE IsAdapterPreferenceSupported( 
+        DXCoreAdapterPreference preference) = 0;
+};
+
+/* interface IDXCoreAdapterFactory */
+MIDL_INTERFACE("78ee5945-c36e-4b13-a669-005dd11c0f06")
+IDXCoreAdapterFactory : public IUnknown
+{
+public:
+
+    virtual HRESULT STDMETHODCALLTYPE CreateAdapterList( 
+        uint32_t numAttributes,
+        _In_reads_(numAttributes) const GUID *filterAttributes,
+        REFIID riid,
+        _COM_Outptr_ void **ppvAdapterList) = 0;
+
+    template<class T>
+    HRESULT STDMETHODCALLTYPE CreateAdapterList( 
+        uint32_t numAttributes,
+        _In_reads_(numAttributes) const GUID *filterAttributes,
+        _COM_Outptr_ T **ppvAdapterList)
+    {
+        return CreateAdapterList(numAttributes,
+                                 filterAttributes,
+                                 IID_PPV_ARGS(ppvAdapterList));
+    }
+
+    virtual HRESULT STDMETHODCALLTYPE GetAdapterByLuid( 
+        const LUID &adapterLUID,
+        REFIID riid,
+        _COM_Outptr_ void **ppvAdapter) = 0;
+
+    template<class T>
+    HRESULT STDMETHODCALLTYPE GetAdapterByLuid( 
+        const LUID &adapterLUID,
+        _COM_Outptr_ T **ppvAdapter)
+    {
+        return GetAdapterByLuid(adapterLUID,
+                                IID_PPV_ARGS(ppvAdapter));
+    }
+
+    virtual bool STDMETHODCALLTYPE IsNotificationTypeSupported( 
+        DXCoreNotificationType notificationType) = 0;
+
+    virtual HRESULT STDMETHODCALLTYPE RegisterEventNotification( 
+        _In_ IUnknown *dxCoreObject,
+        DXCoreNotificationType notificationType,
+        _In_ PFN_DXCORE_NOTIFICATION_CALLBACK callbackFunction,
+        _In_opt_ void *callbackContext,
+        _Out_ uint32_t *eventCookie) = 0;
+
+    virtual HRESULT STDMETHODCALLTYPE UnregisterEventNotification( 
+        uint32_t eventCookie) = 0;
+};
+
+#endif // __cplusplus
+
+#endif // __dxcore_interface_h__
+
+

EscapeTheBackroomsGUiTest/vcpkg_Out/include/directx/dxgicommon.h

@@ -0,0 +1,57 @@
+//
+//    Copyright (C) Microsoft Corporation.
+//    Licensed under the MIT license
+//
+
+#ifndef __dxgicommon_h__
+#define __dxgicommon_h__
+
+
+typedef struct DXGI_RATIONAL
+{
+    UINT Numerator;
+    UINT Denominator;
+} DXGI_RATIONAL;
+
+// The following values are used with DXGI_SAMPLE_DESC::Quality:
+#define DXGI_STANDARD_MULTISAMPLE_QUALITY_PATTERN 0xffffffff
+#define DXGI_CENTER_MULTISAMPLE_QUALITY_PATTERN 0xfffffffe
+
+typedef struct DXGI_SAMPLE_DESC
+{
+    UINT Count;
+    UINT Quality;
+} DXGI_SAMPLE_DESC;
+
+typedef enum DXGI_COLOR_SPACE_TYPE
+{
+    DXGI_COLOR_SPACE_RGB_FULL_G22_NONE_P709             = 0,
+    DXGI_COLOR_SPACE_RGB_FULL_G10_NONE_P709             = 1,
+    DXGI_COLOR_SPACE_RGB_STUDIO_G22_NONE_P709           = 2,
+    DXGI_COLOR_SPACE_RGB_STUDIO_G22_NONE_P2020          = 3,
+    DXGI_COLOR_SPACE_RESERVED                           = 4,
+    DXGI_COLOR_SPACE_YCBCR_FULL_G22_NONE_P709_X601      = 5,
+    DXGI_COLOR_SPACE_YCBCR_STUDIO_G22_LEFT_P601         = 6,
+    DXGI_COLOR_SPACE_YCBCR_FULL_G22_LEFT_P601           = 7,
+    DXGI_COLOR_SPACE_YCBCR_STUDIO_G22_LEFT_P709         = 8,
+    DXGI_COLOR_SPACE_YCBCR_FULL_G22_LEFT_P709           = 9,
+    DXGI_COLOR_SPACE_YCBCR_STUDIO_G22_LEFT_P2020        = 10,
+    DXGI_COLOR_SPACE_YCBCR_FULL_G22_LEFT_P2020          = 11,
+    DXGI_COLOR_SPACE_RGB_FULL_G2084_NONE_P2020          = 12,
+    DXGI_COLOR_SPACE_YCBCR_STUDIO_G2084_LEFT_P2020      = 13,
+    DXGI_COLOR_SPACE_RGB_STUDIO_G2084_NONE_P2020        = 14,
+    DXGI_COLOR_SPACE_YCBCR_STUDIO_G22_TOPLEFT_P2020     = 15,
+    DXGI_COLOR_SPACE_YCBCR_STUDIO_G2084_TOPLEFT_P2020   = 16,
+    DXGI_COLOR_SPACE_RGB_FULL_G22_NONE_P2020            = 17,
+    DXGI_COLOR_SPACE_YCBCR_STUDIO_GHLG_TOPLEFT_P2020    = 18,
+    DXGI_COLOR_SPACE_YCBCR_FULL_GHLG_TOPLEFT_P2020      = 19,
+    DXGI_COLOR_SPACE_RGB_STUDIO_G24_NONE_P709           = 20,
+    DXGI_COLOR_SPACE_RGB_STUDIO_G24_NONE_P2020          = 21,
+    DXGI_COLOR_SPACE_YCBCR_STUDIO_G24_LEFT_P709         = 22,
+    DXGI_COLOR_SPACE_YCBCR_STUDIO_G24_LEFT_P2020        = 23,
+    DXGI_COLOR_SPACE_YCBCR_STUDIO_G24_TOPLEFT_P2020     = 24,
+    DXGI_COLOR_SPACE_CUSTOM                             = 0xFFFFFFFF
+} DXGI_COLOR_SPACE_TYPE;
+
+#endif // __dxgicommon_h__
+

EscapeTheBackroomsGUiTest/vcpkg_Out/include/directx/dxgicommon.idl

@@ -0,0 +1,52 @@
+//
+//    Copyright (C) Microsoft Corporation.
+//    Licensed under the MIT license
+//
+
+
+typedef struct DXGI_RATIONAL
+{
+    UINT Numerator;
+    UINT Denominator;
+} DXGI_RATIONAL;
+
+// The following values are used with DXGI_SAMPLE_DESC::Quality:
+#define DXGI_STANDARD_MULTISAMPLE_QUALITY_PATTERN 0xffffffff
+#define DXGI_CENTER_MULTISAMPLE_QUALITY_PATTERN 0xfffffffe
+
+typedef struct DXGI_SAMPLE_DESC
+{
+    UINT Count;
+    UINT Quality;
+} DXGI_SAMPLE_DESC;
+
+typedef enum DXGI_COLOR_SPACE_TYPE
+{
+    DXGI_COLOR_SPACE_RGB_FULL_G22_NONE_P709             = 0,
+    DXGI_COLOR_SPACE_RGB_FULL_G10_NONE_P709             = 1,
+    DXGI_COLOR_SPACE_RGB_STUDIO_G22_NONE_P709           = 2,
+    DXGI_COLOR_SPACE_RGB_STUDIO_G22_NONE_P2020          = 3,
+    DXGI_COLOR_SPACE_RESERVED                           = 4,
+    DXGI_COLOR_SPACE_YCBCR_FULL_G22_NONE_P709_X601      = 5,
+    DXGI_COLOR_SPACE_YCBCR_STUDIO_G22_LEFT_P601         = 6,
+    DXGI_COLOR_SPACE_YCBCR_FULL_G22_LEFT_P601           = 7,
+    DXGI_COLOR_SPACE_YCBCR_STUDIO_G22_LEFT_P709         = 8,
+    DXGI_COLOR_SPACE_YCBCR_FULL_G22_LEFT_P709           = 9,
+    DXGI_COLOR_SPACE_YCBCR_STUDIO_G22_LEFT_P2020        = 10,
+    DXGI_COLOR_SPACE_YCBCR_FULL_G22_LEFT_P2020          = 11,
+    DXGI_COLOR_SPACE_RGB_FULL_G2084_NONE_P2020          = 12,
+    DXGI_COLOR_SPACE_YCBCR_STUDIO_G2084_LEFT_P2020      = 13,
+    DXGI_COLOR_SPACE_RGB_STUDIO_G2084_NONE_P2020        = 14,
+    DXGI_COLOR_SPACE_YCBCR_STUDIO_G22_TOPLEFT_P2020     = 15,
+    DXGI_COLOR_SPACE_YCBCR_STUDIO_G2084_TOPLEFT_P2020   = 16,
+    DXGI_COLOR_SPACE_RGB_FULL_G22_NONE_P2020            = 17,
+    DXGI_COLOR_SPACE_YCBCR_STUDIO_GHLG_TOPLEFT_P2020    = 18,
+    DXGI_COLOR_SPACE_YCBCR_FULL_GHLG_TOPLEFT_P2020      = 19,
+    DXGI_COLOR_SPACE_RGB_STUDIO_G24_NONE_P709           = 20,
+    DXGI_COLOR_SPACE_RGB_STUDIO_G24_NONE_P2020          = 21,
+    DXGI_COLOR_SPACE_YCBCR_STUDIO_G24_LEFT_P709         = 22,
+    DXGI_COLOR_SPACE_YCBCR_STUDIO_G24_LEFT_P2020        = 23,
+    DXGI_COLOR_SPACE_YCBCR_STUDIO_G24_TOPLEFT_P2020     = 24,
+    DXGI_COLOR_SPACE_CUSTOM                             = 0xFFFFFFFF
+} DXGI_COLOR_SPACE_TYPE;
+

EscapeTheBackroomsGUiTest/vcpkg_Out/include/directx/dxgiformat.h

@@ -0,0 +1,142 @@
+//
+//    Copyright (C) Microsoft Corporation.
+//    Licensed under the MIT license
+//
+
+#ifndef __dxgiformat_h__
+#define __dxgiformat_h__
+
+#define DXGI_FORMAT_DEFINED 1
+
+typedef enum DXGI_FORMAT
+{
+    DXGI_FORMAT_UNKNOWN	                                = 0,
+    DXGI_FORMAT_R32G32B32A32_TYPELESS                   = 1,
+    DXGI_FORMAT_R32G32B32A32_FLOAT                      = 2,
+    DXGI_FORMAT_R32G32B32A32_UINT                       = 3,
+    DXGI_FORMAT_R32G32B32A32_SINT                       = 4,
+    DXGI_FORMAT_R32G32B32_TYPELESS                      = 5,
+    DXGI_FORMAT_R32G32B32_FLOAT                         = 6,
+    DXGI_FORMAT_R32G32B32_UINT                          = 7,
+    DXGI_FORMAT_R32G32B32_SINT                          = 8,
+    DXGI_FORMAT_R16G16B16A16_TYPELESS                   = 9,
+    DXGI_FORMAT_R16G16B16A16_FLOAT                      = 10,
+    DXGI_FORMAT_R16G16B16A16_UNORM                      = 11,
+    DXGI_FORMAT_R16G16B16A16_UINT                       = 12,
+    DXGI_FORMAT_R16G16B16A16_SNORM                      = 13,
+    DXGI_FORMAT_R16G16B16A16_SINT                       = 14,
+    DXGI_FORMAT_R32G32_TYPELESS                         = 15,
+    DXGI_FORMAT_R32G32_FLOAT                            = 16,
+    DXGI_FORMAT_R32G32_UINT                             = 17,
+    DXGI_FORMAT_R32G32_SINT                             = 18,
+    DXGI_FORMAT_R32G8X24_TYPELESS                       = 19,
+    DXGI_FORMAT_D32_FLOAT_S8X24_UINT                    = 20,
+    DXGI_FORMAT_R32_FLOAT_X8X24_TYPELESS                = 21,
+    DXGI_FORMAT_X32_TYPELESS_G8X24_UINT                 = 22,
+    DXGI_FORMAT_R10G10B10A2_TYPELESS                    = 23,
+    DXGI_FORMAT_R10G10B10A2_UNORM                       = 24,
+    DXGI_FORMAT_R10G10B10A2_UINT                        = 25,
+    DXGI_FORMAT_R11G11B10_FLOAT                         = 26,
+    DXGI_FORMAT_R8G8B8A8_TYPELESS                       = 27,
+    DXGI_FORMAT_R8G8B8A8_UNORM                          = 28,
+    DXGI_FORMAT_R8G8B8A8_UNORM_SRGB                     = 29,
+    DXGI_FORMAT_R8G8B8A8_UINT                           = 30,
+    DXGI_FORMAT_R8G8B8A8_SNORM                          = 31,
+    DXGI_FORMAT_R8G8B8A8_SINT                           = 32,
+    DXGI_FORMAT_R16G16_TYPELESS                         = 33,
+    DXGI_FORMAT_R16G16_FLOAT                            = 34,
+    DXGI_FORMAT_R16G16_UNORM                            = 35,
+    DXGI_FORMAT_R16G16_UINT                             = 36,
+    DXGI_FORMAT_R16G16_SNORM                            = 37,
+    DXGI_FORMAT_R16G16_SINT                             = 38,
+    DXGI_FORMAT_R32_TYPELESS                            = 39,
+    DXGI_FORMAT_D32_FLOAT                               = 40,
+    DXGI_FORMAT_R32_FLOAT                               = 41,
+    DXGI_FORMAT_R32_UINT                                = 42,
+    DXGI_FORMAT_R32_SINT                                = 43,
+    DXGI_FORMAT_R24G8_TYPELESS                          = 44,
+    DXGI_FORMAT_D24_UNORM_S8_UINT                       = 45,
+    DXGI_FORMAT_R24_UNORM_X8_TYPELESS                   = 46,
+    DXGI_FORMAT_X24_TYPELESS_G8_UINT                    = 47,
+    DXGI_FORMAT_R8G8_TYPELESS                           = 48,
+    DXGI_FORMAT_R8G8_UNORM                              = 49,
+    DXGI_FORMAT_R8G8_UINT                               = 50,
+    DXGI_FORMAT_R8G8_SNORM                              = 51,
+    DXGI_FORMAT_R8G8_SINT                               = 52,
+    DXGI_FORMAT_R16_TYPELESS                            = 53,
+    DXGI_FORMAT_R16_FLOAT                               = 54,
+    DXGI_FORMAT_D16_UNORM                               = 55,
+    DXGI_FORMAT_R16_UNORM                               = 56,
+    DXGI_FORMAT_R16_UINT                                = 57,
+    DXGI_FORMAT_R16_SNORM                               = 58,
+    DXGI_FORMAT_R16_SINT                                = 59,
+    DXGI_FORMAT_R8_TYPELESS                             = 60,
+    DXGI_FORMAT_R8_UNORM                                = 61,
+    DXGI_FORMAT_R8_UINT                                 = 62,
+    DXGI_FORMAT_R8_SNORM                                = 63,
+    DXGI_FORMAT_R8_SINT                                 = 64,
+    DXGI_FORMAT_A8_UNORM                                = 65,
+    DXGI_FORMAT_R1_UNORM                                = 66,
+    DXGI_FORMAT_R9G9B9E5_SHAREDEXP                      = 67,
+    DXGI_FORMAT_R8G8_B8G8_UNORM                         = 68,
+    DXGI_FORMAT_G8R8_G8B8_UNORM                         = 69,
+    DXGI_FORMAT_BC1_TYPELESS                            = 70,
+    DXGI_FORMAT_BC1_UNORM                               = 71,
+    DXGI_FORMAT_BC1_UNORM_SRGB                          = 72,
+    DXGI_FORMAT_BC2_TYPELESS                            = 73,
+    DXGI_FORMAT_BC2_UNORM                               = 74,
+    DXGI_FORMAT_BC2_UNORM_SRGB                          = 75,
+    DXGI_FORMAT_BC3_TYPELESS                            = 76,
+    DXGI_FORMAT_BC3_UNORM                               = 77,
+    DXGI_FORMAT_BC3_UNORM_SRGB                          = 78,
+    DXGI_FORMAT_BC4_TYPELESS                            = 79,
+    DXGI_FORMAT_BC4_UNORM                               = 80,
+    DXGI_FORMAT_BC4_SNORM                               = 81,
+    DXGI_FORMAT_BC5_TYPELESS                            = 82,
+    DXGI_FORMAT_BC5_UNORM                               = 83,
+    DXGI_FORMAT_BC5_SNORM                               = 84,
+    DXGI_FORMAT_B5G6R5_UNORM                            = 85,
+    DXGI_FORMAT_B5G5R5A1_UNORM                          = 86,
+    DXGI_FORMAT_B8G8R8A8_UNORM                          = 87,
+    DXGI_FORMAT_B8G8R8X8_UNORM                          = 88,
+    DXGI_FORMAT_R10G10B10_XR_BIAS_A2_UNORM              = 89,
+    DXGI_FORMAT_B8G8R8A8_TYPELESS                       = 90,
+    DXGI_FORMAT_B8G8R8A8_UNORM_SRGB                     = 91,
+    DXGI_FORMAT_B8G8R8X8_TYPELESS                       = 92,
+    DXGI_FORMAT_B8G8R8X8_UNORM_SRGB                     = 93,
+    DXGI_FORMAT_BC6H_TYPELESS                           = 94,
+    DXGI_FORMAT_BC6H_UF16                               = 95,
+    DXGI_FORMAT_BC6H_SF16                               = 96,
+    DXGI_FORMAT_BC7_TYPELESS                            = 97,
+    DXGI_FORMAT_BC7_UNORM                               = 98,
+    DXGI_FORMAT_BC7_UNORM_SRGB                          = 99,
+    DXGI_FORMAT_AYUV                                    = 100,
+    DXGI_FORMAT_Y410                                    = 101,
+    DXGI_FORMAT_Y416                                    = 102,
+    DXGI_FORMAT_NV12                                    = 103,
+    DXGI_FORMAT_P010                                    = 104,
+    DXGI_FORMAT_P016                                    = 105,
+    DXGI_FORMAT_420_OPAQUE                              = 106,
+    DXGI_FORMAT_YUY2                                    = 107,
+    DXGI_FORMAT_Y210                                    = 108,
+    DXGI_FORMAT_Y216                                    = 109,
+    DXGI_FORMAT_NV11                                    = 110,
+    DXGI_FORMAT_AI44                                    = 111,
+    DXGI_FORMAT_IA44                                    = 112,
+    DXGI_FORMAT_P8                                      = 113,
+    DXGI_FORMAT_A8P8                                    = 114,
+    DXGI_FORMAT_B4G4R4A4_UNORM                          = 115,
+
+    DXGI_FORMAT_P208                                    = 130,
+    DXGI_FORMAT_V208                                    = 131,
+    DXGI_FORMAT_V408                                    = 132,
+
+
+    DXGI_FORMAT_SAMPLER_FEEDBACK_MIN_MIP_OPAQUE         = 189,
+    DXGI_FORMAT_SAMPLER_FEEDBACK_MIP_REGION_USED_OPAQUE = 190,
+
+
+    DXGI_FORMAT_FORCE_UINT                  = 0xffffffff
+} DXGI_FORMAT;
+
+#endif // __dxgiformat_h__

EscapeTheBackroomsGUiTest/vcpkg_Out/include/directx/dxgiformat.idl

@@ -0,0 +1,137 @@
+//
+//    Copyright (C) Microsoft Corporation.
+//    Licensed under the MIT license
+//
+
+
+typedef enum DXGI_FORMAT
+{
+    DXGI_FORMAT_UNKNOWN	                                = 0,
+    DXGI_FORMAT_R32G32B32A32_TYPELESS                   = 1,
+    DXGI_FORMAT_R32G32B32A32_FLOAT                      = 2,
+    DXGI_FORMAT_R32G32B32A32_UINT                       = 3,
+    DXGI_FORMAT_R32G32B32A32_SINT                       = 4,
+    DXGI_FORMAT_R32G32B32_TYPELESS                      = 5,
+    DXGI_FORMAT_R32G32B32_FLOAT                         = 6,
+    DXGI_FORMAT_R32G32B32_UINT                          = 7,
+    DXGI_FORMAT_R32G32B32_SINT                          = 8,
+    DXGI_FORMAT_R16G16B16A16_TYPELESS                   = 9,
+    DXGI_FORMAT_R16G16B16A16_FLOAT                      = 10,
+    DXGI_FORMAT_R16G16B16A16_UNORM                      = 11,
+    DXGI_FORMAT_R16G16B16A16_UINT                       = 12,
+    DXGI_FORMAT_R16G16B16A16_SNORM                      = 13,
+    DXGI_FORMAT_R16G16B16A16_SINT                       = 14,
+    DXGI_FORMAT_R32G32_TYPELESS                         = 15,
+    DXGI_FORMAT_R32G32_FLOAT                            = 16,
+    DXGI_FORMAT_R32G32_UINT                             = 17,
+    DXGI_FORMAT_R32G32_SINT                             = 18,
+    DXGI_FORMAT_R32G8X24_TYPELESS                       = 19,
+    DXGI_FORMAT_D32_FLOAT_S8X24_UINT                    = 20,
+    DXGI_FORMAT_R32_FLOAT_X8X24_TYPELESS                = 21,
+    DXGI_FORMAT_X32_TYPELESS_G8X24_UINT                 = 22,
+    DXGI_FORMAT_R10G10B10A2_TYPELESS                    = 23,
+    DXGI_FORMAT_R10G10B10A2_UNORM                       = 24,
+    DXGI_FORMAT_R10G10B10A2_UINT                        = 25,
+    DXGI_FORMAT_R11G11B10_FLOAT                         = 26,
+    DXGI_FORMAT_R8G8B8A8_TYPELESS                       = 27,
+    DXGI_FORMAT_R8G8B8A8_UNORM                          = 28,
+    DXGI_FORMAT_R8G8B8A8_UNORM_SRGB                     = 29,
+    DXGI_FORMAT_R8G8B8A8_UINT                           = 30,
+    DXGI_FORMAT_R8G8B8A8_SNORM                          = 31,
+    DXGI_FORMAT_R8G8B8A8_SINT                           = 32,
+    DXGI_FORMAT_R16G16_TYPELESS                         = 33,
+    DXGI_FORMAT_R16G16_FLOAT                            = 34,
+    DXGI_FORMAT_R16G16_UNORM                            = 35,
+    DXGI_FORMAT_R16G16_UINT                             = 36,
+    DXGI_FORMAT_R16G16_SNORM                            = 37,
+    DXGI_FORMAT_R16G16_SINT                             = 38,
+    DXGI_FORMAT_R32_TYPELESS                            = 39,
+    DXGI_FORMAT_D32_FLOAT                               = 40,
+    DXGI_FORMAT_R32_FLOAT                               = 41,
+    DXGI_FORMAT_R32_UINT                                = 42,
+    DXGI_FORMAT_R32_SINT                                = 43,
+    DXGI_FORMAT_R24G8_TYPELESS                          = 44,
+    DXGI_FORMAT_D24_UNORM_S8_UINT                       = 45,
+    DXGI_FORMAT_R24_UNORM_X8_TYPELESS                   = 46,
+    DXGI_FORMAT_X24_TYPELESS_G8_UINT                    = 47,
+    DXGI_FORMAT_R8G8_TYPELESS                           = 48,
+    DXGI_FORMAT_R8G8_UNORM                              = 49,
+    DXGI_FORMAT_R8G8_UINT                               = 50,
+    DXGI_FORMAT_R8G8_SNORM                              = 51,
+    DXGI_FORMAT_R8G8_SINT                               = 52,
+    DXGI_FORMAT_R16_TYPELESS                            = 53,
+    DXGI_FORMAT_R16_FLOAT                               = 54,
+    DXGI_FORMAT_D16_UNORM                               = 55,
+    DXGI_FORMAT_R16_UNORM                               = 56,
+    DXGI_FORMAT_R16_UINT                                = 57,
+    DXGI_FORMAT_R16_SNORM                               = 58,
+    DXGI_FORMAT_R16_SINT                                = 59,
+    DXGI_FORMAT_R8_TYPELESS                             = 60,
+    DXGI_FORMAT_R8_UNORM                                = 61,
+    DXGI_FORMAT_R8_UINT                                 = 62,
+    DXGI_FORMAT_R8_SNORM                                = 63,
+    DXGI_FORMAT_R8_SINT                                 = 64,
+    DXGI_FORMAT_A8_UNORM                                = 65,
+    DXGI_FORMAT_R1_UNORM                                = 66,
+    DXGI_FORMAT_R9G9B9E5_SHAREDEXP                      = 67,
+    DXGI_FORMAT_R8G8_B8G8_UNORM                         = 68,
+    DXGI_FORMAT_G8R8_G8B8_UNORM                         = 69,
+    DXGI_FORMAT_BC1_TYPELESS                            = 70,
+    DXGI_FORMAT_BC1_UNORM                               = 71,
+    DXGI_FORMAT_BC1_UNORM_SRGB                          = 72,
+    DXGI_FORMAT_BC2_TYPELESS                            = 73,
+    DXGI_FORMAT_BC2_UNORM                               = 74,
+    DXGI_FORMAT_BC2_UNORM_SRGB                          = 75,
+    DXGI_FORMAT_BC3_TYPELESS                            = 76,
+    DXGI_FORMAT_BC3_UNORM                               = 77,
+    DXGI_FORMAT_BC3_UNORM_SRGB                          = 78,
+    DXGI_FORMAT_BC4_TYPELESS                            = 79,
+    DXGI_FORMAT_BC4_UNORM                               = 80,
+    DXGI_FORMAT_BC4_SNORM                               = 81,
+    DXGI_FORMAT_BC5_TYPELESS                            = 82,
+    DXGI_FORMAT_BC5_UNORM                               = 83,
+    DXGI_FORMAT_BC5_SNORM                               = 84,
+    DXGI_FORMAT_B5G6R5_UNORM                            = 85,
+    DXGI_FORMAT_B5G5R5A1_UNORM                          = 86,
+    DXGI_FORMAT_B8G8R8A8_UNORM                          = 87,
+    DXGI_FORMAT_B8G8R8X8_UNORM                          = 88,
+    DXGI_FORMAT_R10G10B10_XR_BIAS_A2_UNORM              = 89,
+    DXGI_FORMAT_B8G8R8A8_TYPELESS                       = 90,
+    DXGI_FORMAT_B8G8R8A8_UNORM_SRGB                     = 91,
+    DXGI_FORMAT_B8G8R8X8_TYPELESS                       = 92,
+    DXGI_FORMAT_B8G8R8X8_UNORM_SRGB                     = 93,
+    DXGI_FORMAT_BC6H_TYPELESS                           = 94,
+    DXGI_FORMAT_BC6H_UF16                               = 95,
+    DXGI_FORMAT_BC6H_SF16                               = 96,
+    DXGI_FORMAT_BC7_TYPELESS                            = 97,
+    DXGI_FORMAT_BC7_UNORM                               = 98,
+    DXGI_FORMAT_BC7_UNORM_SRGB                          = 99,
+    DXGI_FORMAT_AYUV                                    = 100,
+    DXGI_FORMAT_Y410                                    = 101,
+    DXGI_FORMAT_Y416                                    = 102,
+    DXGI_FORMAT_NV12                                    = 103,
+    DXGI_FORMAT_P010                                    = 104,
+    DXGI_FORMAT_P016                                    = 105,
+    DXGI_FORMAT_420_OPAQUE                              = 106,
+    DXGI_FORMAT_YUY2                                    = 107,
+    DXGI_FORMAT_Y210                                    = 108,
+    DXGI_FORMAT_Y216                                    = 109,
+    DXGI_FORMAT_NV11                                    = 110,
+    DXGI_FORMAT_AI44                                    = 111,
+    DXGI_FORMAT_IA44                                    = 112,
+    DXGI_FORMAT_P8                                      = 113,
+    DXGI_FORMAT_A8P8                                    = 114,
+    DXGI_FORMAT_B4G4R4A4_UNORM                          = 115,
+
+    DXGI_FORMAT_P208                                    = 130,
+    DXGI_FORMAT_V208                                    = 131,
+    DXGI_FORMAT_V408                                    = 132,
+
+
+    DXGI_FORMAT_SAMPLER_FEEDBACK_MIN_MIP_OPAQUE         = 189,
+    DXGI_FORMAT_SAMPLER_FEEDBACK_MIP_REGION_USED_OPAQUE = 190,
+
+
+    DXGI_FORMAT_FORCE_UINT                  = 0xffffffff
+} DXGI_FORMAT;
+

EscapeTheBackroomsGUiTest/vcpkg_Out/include/directxmath/DirectXCollision.h

@@ -0,0 +1,359 @@
+//-------------------------------------------------------------------------------------
+// DirectXCollision.h -- C++ Collision Math library
+//
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+//
+// http://go.microsoft.com/fwlink/?LinkID=615560
+//-------------------------------------------------------------------------------------
+
+#pragma once
+
+#include "DirectXMath.h"
+
+namespace DirectX
+{
+
+    enum ContainmentType
+    {
+        DISJOINT = 0,
+        INTERSECTS = 1,
+        CONTAINS = 2
+    };
+
+    enum PlaneIntersectionType
+    {
+        FRONT = 0,
+        INTERSECTING = 1,
+        BACK = 2
+    };
+
+    struct BoundingBox;
+    struct BoundingOrientedBox;
+    struct BoundingFrustum;
+
+#ifdef _MSC_VER
+#pragma warning(push)
+#pragma warning(disable:4324 4820)
+    // C4324: alignment padding warnings
+    // C4820: Off by default noise
+#endif
+
+    //-------------------------------------------------------------------------------------
+    // Bounding sphere
+    //-------------------------------------------------------------------------------------
+    struct BoundingSphere
+    {
+        XMFLOAT3 Center;            // Center of the sphere.
+        float Radius;               // Radius of the sphere.
+
+        // Creators
+        BoundingSphere() noexcept : Center(0, 0, 0), Radius(1.f) {}
+
+        BoundingSphere(const BoundingSphere&) = default;
+        BoundingSphere& operator=(const BoundingSphere&) = default;
+
+        BoundingSphere(BoundingSphere&&) = default;
+        BoundingSphere& operator=(BoundingSphere&&) = default;
+
+        constexpr BoundingSphere(_In_ const XMFLOAT3& center, _In_ float radius) noexcept
+            : Center(center), Radius(radius) {}
+
+        // Methods
+        void    XM_CALLCONV     Transform(_Out_ BoundingSphere& Out, _In_ FXMMATRIX M) const noexcept;
+        void    XM_CALLCONV     Transform(_Out_ BoundingSphere& Out, _In_ float Scale, _In_ FXMVECTOR Rotation, _In_ FXMVECTOR Translation) const noexcept;
+        // Transform the sphere
+
+        ContainmentType    XM_CALLCONV     Contains(_In_ FXMVECTOR Point) const noexcept;
+        ContainmentType    XM_CALLCONV     Contains(_In_ FXMVECTOR V0, _In_ FXMVECTOR V1, _In_ FXMVECTOR V2) const noexcept;
+        ContainmentType Contains(_In_ const BoundingSphere& sh) const noexcept;
+        ContainmentType Contains(_In_ const BoundingBox& box) const noexcept;
+        ContainmentType Contains(_In_ const BoundingOrientedBox& box) const noexcept;
+        ContainmentType Contains(_In_ const BoundingFrustum& fr) const noexcept;
+
+        bool Intersects(_In_ const BoundingSphere& sh) const noexcept;
+        bool Intersects(_In_ const BoundingBox& box) const noexcept;
+        bool Intersects(_In_ const BoundingOrientedBox& box) const noexcept;
+        bool Intersects(_In_ const BoundingFrustum& fr) const noexcept;
+
+        bool    XM_CALLCONV     Intersects(_In_ FXMVECTOR V0, _In_ FXMVECTOR V1, _In_ FXMVECTOR V2) const noexcept;
+        // Triangle-sphere test
+
+        PlaneIntersectionType    XM_CALLCONV     Intersects(_In_ FXMVECTOR Plane) const noexcept;
+        // Plane-sphere test
+
+        bool    XM_CALLCONV     Intersects(_In_ FXMVECTOR Origin, _In_ FXMVECTOR Direction, _Out_ float& Dist) const noexcept;
+        // Ray-sphere test
+
+        ContainmentType     XM_CALLCONV     ContainedBy(_In_ FXMVECTOR Plane0, _In_ FXMVECTOR Plane1, _In_ FXMVECTOR Plane2,
+            _In_ GXMVECTOR Plane3, _In_ HXMVECTOR Plane4, _In_ HXMVECTOR Plane5) const noexcept;
+        // Test sphere against six planes (see BoundingFrustum::GetPlanes)
+
+        // Static methods
+        static void CreateMerged(_Out_ BoundingSphere& Out, _In_ const BoundingSphere& S1, _In_ const BoundingSphere& S2) noexcept;
+
+        static void CreateFromBoundingBox(_Out_ BoundingSphere& Out, _In_ const BoundingBox& box) noexcept;
+        static void CreateFromBoundingBox(_Out_ BoundingSphere& Out, _In_ const BoundingOrientedBox& box) noexcept;
+
+        static void CreateFromPoints(_Out_ BoundingSphere& Out, _In_ size_t Count,
+            _In_reads_bytes_(sizeof(XMFLOAT3) + Stride * (Count - 1)) const XMFLOAT3* pPoints, _In_ size_t Stride) noexcept;
+
+        static void CreateFromFrustum(_Out_ BoundingSphere& Out, _In_ const BoundingFrustum& fr) noexcept;
+    };
+
+    //-------------------------------------------------------------------------------------
+    // Axis-aligned bounding box
+    //-------------------------------------------------------------------------------------
+    struct BoundingBox
+    {
+        static constexpr size_t CORNER_COUNT = 8;
+
+        XMFLOAT3 Center;            // Center of the box.
+        XMFLOAT3 Extents;           // Distance from the center to each side.
+
+        // Creators
+        BoundingBox() noexcept : Center(0, 0, 0), Extents(1.f, 1.f, 1.f) {}
+
+        BoundingBox(const BoundingBox&) = default;
+        BoundingBox& operator=(const BoundingBox&) = default;
+
+        BoundingBox(BoundingBox&&) = default;
+        BoundingBox& operator=(BoundingBox&&) = default;
+
+        constexpr BoundingBox(_In_ const XMFLOAT3& center, _In_ const XMFLOAT3& extents) noexcept
+            : Center(center), Extents(extents) {}
+
+        // Methods
+        void    XM_CALLCONV     Transform(_Out_ BoundingBox& Out, _In_ FXMMATRIX M) const noexcept;
+        void    XM_CALLCONV     Transform(_Out_ BoundingBox& Out, _In_ float Scale, _In_ FXMVECTOR Rotation, _In_ FXMVECTOR Translation) const noexcept;
+
+        void GetCorners(_Out_writes_(8) XMFLOAT3* Corners) const noexcept;
+        // Gets the 8 corners of the box
+
+        ContainmentType    XM_CALLCONV     Contains(_In_ FXMVECTOR Point) const noexcept;
+        ContainmentType    XM_CALLCONV     Contains(_In_ FXMVECTOR V0, _In_ FXMVECTOR V1, _In_ FXMVECTOR V2) const noexcept;
+        ContainmentType Contains(_In_ const BoundingSphere& sh) const noexcept;
+        ContainmentType Contains(_In_ const BoundingBox& box) const noexcept;
+        ContainmentType Contains(_In_ const BoundingOrientedBox& box) const noexcept;
+        ContainmentType Contains(_In_ const BoundingFrustum& fr) const noexcept;
+
+        bool Intersects(_In_ const BoundingSphere& sh) const noexcept;
+        bool Intersects(_In_ const BoundingBox& box) const noexcept;
+        bool Intersects(_In_ const BoundingOrientedBox& box) const noexcept;
+        bool Intersects(_In_ const BoundingFrustum& fr) const noexcept;
+
+        bool    XM_CALLCONV     Intersects(_In_ FXMVECTOR V0, _In_ FXMVECTOR V1, _In_ FXMVECTOR V2) const noexcept;
+        // Triangle-Box test
+
+        PlaneIntersectionType    XM_CALLCONV     Intersects(_In_ FXMVECTOR Plane) const noexcept;
+        // Plane-box test
+
+        bool    XM_CALLCONV     Intersects(_In_ FXMVECTOR Origin, _In_ FXMVECTOR Direction, _Out_ float& Dist) const noexcept;
+        // Ray-Box test
+
+        ContainmentType     XM_CALLCONV     ContainedBy(_In_ FXMVECTOR Plane0, _In_ FXMVECTOR Plane1, _In_ FXMVECTOR Plane2,
+            _In_ GXMVECTOR Plane3, _In_ HXMVECTOR Plane4, _In_ HXMVECTOR Plane5) const noexcept;
+        // Test box against six planes (see BoundingFrustum::GetPlanes)
+
+        // Static methods
+        static void CreateMerged(_Out_ BoundingBox& Out, _In_ const BoundingBox& b1, _In_ const BoundingBox& b2) noexcept;
+
+        static void CreateFromSphere(_Out_ BoundingBox& Out, _In_ const BoundingSphere& sh) noexcept;
+
+        static void    XM_CALLCONV     CreateFromPoints(_Out_ BoundingBox& Out, _In_ FXMVECTOR pt1, _In_ FXMVECTOR pt2) noexcept;
+        static void CreateFromPoints(_Out_ BoundingBox& Out, _In_ size_t Count,
+            _In_reads_bytes_(sizeof(XMFLOAT3) + Stride * (Count - 1)) const XMFLOAT3* pPoints, _In_ size_t Stride) noexcept;
+    };
+
+    //-------------------------------------------------------------------------------------
+    // Oriented bounding box
+    //-------------------------------------------------------------------------------------
+    struct BoundingOrientedBox
+    {
+        static constexpr size_t CORNER_COUNT = 8;
+
+        XMFLOAT3 Center;            // Center of the box.
+        XMFLOAT3 Extents;           // Distance from the center to each side.
+        XMFLOAT4 Orientation;       // Unit quaternion representing rotation (box -> world).
+
+        // Creators
+        BoundingOrientedBox() noexcept : Center(0, 0, 0), Extents(1.f, 1.f, 1.f), Orientation(0, 0, 0, 1.f) {}
+
+        BoundingOrientedBox(const BoundingOrientedBox&) = default;
+        BoundingOrientedBox& operator=(const BoundingOrientedBox&) = default;
+
+        BoundingOrientedBox(BoundingOrientedBox&&) = default;
+        BoundingOrientedBox& operator=(BoundingOrientedBox&&) = default;
+
+        constexpr BoundingOrientedBox(_In_ const XMFLOAT3& center, _In_ const XMFLOAT3& extents, _In_ const XMFLOAT4& orientation) noexcept
+            : Center(center), Extents(extents), Orientation(orientation) {}
+
+        // Methods
+        void    XM_CALLCONV     Transform(_Out_ BoundingOrientedBox& Out, _In_ FXMMATRIX M) const noexcept;
+        void    XM_CALLCONV     Transform(_Out_ BoundingOrientedBox& Out, _In_ float Scale, _In_ FXMVECTOR Rotation, _In_ FXMVECTOR Translation) const noexcept;
+
+        void GetCorners(_Out_writes_(8) XMFLOAT3* Corners) const noexcept;
+        // Gets the 8 corners of the box
+
+        ContainmentType    XM_CALLCONV     Contains(_In_ FXMVECTOR Point) const noexcept;
+        ContainmentType    XM_CALLCONV     Contains(_In_ FXMVECTOR V0, _In_ FXMVECTOR V1, _In_ FXMVECTOR V2) const noexcept;
+        ContainmentType Contains(_In_ const BoundingSphere& sh) const noexcept;
+        ContainmentType Contains(_In_ const BoundingBox& box) const noexcept;
+        ContainmentType Contains(_In_ const BoundingOrientedBox& box) const noexcept;
+        ContainmentType Contains(_In_ const BoundingFrustum& fr) const noexcept;
+
+        bool Intersects(_In_ const BoundingSphere& sh) const noexcept;
+        bool Intersects(_In_ const BoundingBox& box) const noexcept;
+        bool Intersects(_In_ const BoundingOrientedBox& box) const noexcept;
+        bool Intersects(_In_ const BoundingFrustum& fr) const noexcept;
+
+        bool    XM_CALLCONV     Intersects(_In_ FXMVECTOR V0, _In_ FXMVECTOR V1, _In_ FXMVECTOR V2) const noexcept;
+        // Triangle-OrientedBox test
+
+        PlaneIntersectionType    XM_CALLCONV     Intersects(_In_ FXMVECTOR Plane) const noexcept;
+        // Plane-OrientedBox test
+
+        bool    XM_CALLCONV     Intersects(_In_ FXMVECTOR Origin, _In_ FXMVECTOR Direction, _Out_ float& Dist) const noexcept;
+        // Ray-OrientedBox test
+
+        ContainmentType     XM_CALLCONV     ContainedBy(_In_ FXMVECTOR Plane0, _In_ FXMVECTOR Plane1, _In_ FXMVECTOR Plane2,
+            _In_ GXMVECTOR Plane3, _In_ HXMVECTOR Plane4, _In_ HXMVECTOR Plane5) const noexcept;
+        // Test OrientedBox against six planes (see BoundingFrustum::GetPlanes)
+
+        // Static methods
+        static void CreateFromBoundingBox(_Out_ BoundingOrientedBox& Out, _In_ const BoundingBox& box) noexcept;
+
+        static void CreateFromPoints(_Out_ BoundingOrientedBox& Out, _In_ size_t Count,
+            _In_reads_bytes_(sizeof(XMFLOAT3) + Stride * (Count - 1)) const XMFLOAT3* pPoints, _In_ size_t Stride) noexcept;
+    };
+
+    //-------------------------------------------------------------------------------------
+    // Bounding frustum
+    //-------------------------------------------------------------------------------------
+    struct BoundingFrustum
+    {
+        static constexpr size_t CORNER_COUNT = 8;
+
+        XMFLOAT3 Origin;            // Origin of the frustum (and projection).
+        XMFLOAT4 Orientation;       // Quaternion representing rotation.
+
+        float RightSlope;           // Positive X (X/Z)
+        float LeftSlope;            // Negative X
+        float TopSlope;             // Positive Y (Y/Z)
+        float BottomSlope;          // Negative Y
+        float Near, Far;            // Z of the near plane and far plane.
+
+        // Creators
+        BoundingFrustum() noexcept :
+            Origin(0, 0, 0), Orientation(0, 0, 0, 1.f), RightSlope(1.f), LeftSlope(-1.f),
+            TopSlope(1.f), BottomSlope(-1.f), Near(0), Far(1.f) {}
+
+        BoundingFrustum(const BoundingFrustum&) = default;
+        BoundingFrustum& operator=(const BoundingFrustum&) = default;
+
+        BoundingFrustum(BoundingFrustum&&) = default;
+        BoundingFrustum& operator=(BoundingFrustum&&) = default;
+
+        constexpr BoundingFrustum(_In_ const XMFLOAT3& origin, _In_ const XMFLOAT4& orientation,
+            _In_ float rightSlope, _In_ float leftSlope, _In_ float topSlope, _In_ float bottomSlope,
+            _In_ float nearPlane, _In_ float farPlane) noexcept
+            : Origin(origin), Orientation(orientation),
+            RightSlope(rightSlope), LeftSlope(leftSlope), TopSlope(topSlope), BottomSlope(bottomSlope),
+            Near(nearPlane), Far(farPlane) {}
+        BoundingFrustum(_In_ CXMMATRIX Projection, bool rhcoords = false) noexcept;
+
+        // Methods
+        void    XM_CALLCONV     Transform(_Out_ BoundingFrustum& Out, _In_ FXMMATRIX M) const noexcept;
+        void    XM_CALLCONV     Transform(_Out_ BoundingFrustum& Out, _In_ float Scale, _In_ FXMVECTOR Rotation, _In_ FXMVECTOR Translation) const noexcept;
+
+        void GetCorners(_Out_writes_(8) XMFLOAT3* Corners) const noexcept;
+        // Gets the 8 corners of the frustum
+
+        ContainmentType    XM_CALLCONV     Contains(_In_ FXMVECTOR Point) const noexcept;
+        ContainmentType    XM_CALLCONV     Contains(_In_ FXMVECTOR V0, _In_ FXMVECTOR V1, _In_ FXMVECTOR V2) const noexcept;
+        ContainmentType Contains(_In_ const BoundingSphere& sp) const noexcept;
+        ContainmentType Contains(_In_ const BoundingBox& box) const noexcept;
+        ContainmentType Contains(_In_ const BoundingOrientedBox& box) const noexcept;
+        ContainmentType Contains(_In_ const BoundingFrustum& fr) const noexcept;
+        // Frustum-Frustum test
+
+        bool Intersects(_In_ const BoundingSphere& sh) const noexcept;
+        bool Intersects(_In_ const BoundingBox& box) const noexcept;
+        bool Intersects(_In_ const BoundingOrientedBox& box) const noexcept;
+        bool Intersects(_In_ const BoundingFrustum& fr) const noexcept;
+
+        bool    XM_CALLCONV     Intersects(_In_ FXMVECTOR V0, _In_ FXMVECTOR V1, _In_ FXMVECTOR V2) const noexcept;
+        // Triangle-Frustum test
+
+        PlaneIntersectionType    XM_CALLCONV     Intersects(_In_ FXMVECTOR Plane) const noexcept;
+        // Plane-Frustum test
+
+        bool    XM_CALLCONV     Intersects(_In_ FXMVECTOR rayOrigin, _In_ FXMVECTOR Direction, _Out_ float& Dist) const noexcept;
+        // Ray-Frustum test
+
+        ContainmentType     XM_CALLCONV     ContainedBy(_In_ FXMVECTOR Plane0, _In_ FXMVECTOR Plane1, _In_ FXMVECTOR Plane2,
+            _In_ GXMVECTOR Plane3, _In_ HXMVECTOR Plane4, _In_ HXMVECTOR Plane5) const noexcept;
+        // Test frustum against six planes (see BoundingFrustum::GetPlanes)
+
+        void GetPlanes(_Out_opt_ XMVECTOR* NearPlane, _Out_opt_ XMVECTOR* FarPlane, _Out_opt_ XMVECTOR* RightPlane,
+            _Out_opt_ XMVECTOR* LeftPlane, _Out_opt_ XMVECTOR* TopPlane, _Out_opt_ XMVECTOR* BottomPlane) const noexcept;
+        // Create 6 Planes representation of Frustum
+
+        // Static methods
+        static void     XM_CALLCONV     CreateFromMatrix(_Out_ BoundingFrustum& Out, _In_ FXMMATRIX Projection, bool rhcoords = false) noexcept;
+    };
+
+    //-----------------------------------------------------------------------------
+    // Triangle intersection testing routines.
+    //-----------------------------------------------------------------------------
+    namespace TriangleTests
+    {
+        bool                    XM_CALLCONV     Intersects(_In_ FXMVECTOR Origin, _In_ FXMVECTOR Direction, _In_ FXMVECTOR V0, _In_ GXMVECTOR V1, _In_ HXMVECTOR V2, _Out_ float& Dist) noexcept;
+        // Ray-Triangle
+
+        bool                    XM_CALLCONV     Intersects(_In_ FXMVECTOR A0, _In_ FXMVECTOR A1, _In_ FXMVECTOR A2, _In_ GXMVECTOR B0, _In_ HXMVECTOR B1, _In_ HXMVECTOR B2) noexcept;
+        // Triangle-Triangle
+
+        PlaneIntersectionType   XM_CALLCONV     Intersects(_In_ FXMVECTOR V0, _In_ FXMVECTOR V1, _In_ FXMVECTOR V2, _In_ GXMVECTOR Plane) noexcept;
+        // Plane-Triangle
+
+        ContainmentType         XM_CALLCONV     ContainedBy(_In_ FXMVECTOR V0, _In_ FXMVECTOR V1, _In_ FXMVECTOR V2,
+            _In_ GXMVECTOR Plane0, _In_ HXMVECTOR Plane1, _In_ HXMVECTOR Plane2,
+            _In_ CXMVECTOR Plane3, _In_ CXMVECTOR Plane4, _In_ CXMVECTOR Plane5) noexcept;
+        // Test a triangle against six planes at once (see BoundingFrustum::GetPlanes)
+    }
+
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif
+
+    /****************************************************************************
+     *
+     * Implementation
+     *
+     ****************************************************************************/
+
+#ifdef _MSC_VER
+#pragma warning(push)
+#pragma warning(disable : 4068 4365 4616 6001)
+     // C4068/4616: ignore unknown pragmas
+     // C4365: Off by default noise
+     // C6001: False positives
+#endif
+#ifdef _PREFAST_
+#pragma prefast(push)
+#pragma prefast(disable : 25000, "FXMVECTOR is 16 bytes")
+#pragma prefast(disable : 26495, "Union initialization confuses /analyze")
+#endif
+
+#include "DirectXCollision.inl"
+
+#ifdef _PREFAST_
+#pragma prefast(pop)
+#endif
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif
+
+} // namespace DirectX
+

EscapeTheBackroomsGUiTest/vcpkg_Out/include/directxmath/DirectXColors.h

@@ -0,0 +1,312 @@
+//-------------------------------------------------------------------------------------
+// DirectXColors.h -- C++ Color Math library
+//
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+//
+// http://go.microsoft.com/fwlink/?LinkID=615560
+//-------------------------------------------------------------------------------------
+
+#pragma once
+
+#include "DirectXMath.h"
+
+namespace DirectX
+{
+
+    namespace Colors
+    {
+        // Standard colors (Red/Green/Blue/Alpha) in sRGB colorspace
+        XMGLOBALCONST XMVECTORF32 AliceBlue = { { { 0.941176534f, 0.972549081f, 1.f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 AntiqueWhite = { { { 0.980392218f, 0.921568692f, 0.843137324f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 Aqua = { { { 0.f, 1.f, 1.f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 Aquamarine = { { { 0.498039246f, 1.f, 0.831372619f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 Azure = { { { 0.941176534f, 1.f, 1.f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 Beige = { { { 0.960784376f, 0.960784376f, 0.862745166f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 Bisque = { { { 1.f, 0.894117713f, 0.768627524f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 Black = { { { 0.f, 0.f, 0.f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 BlanchedAlmond = { { { 1.f, 0.921568692f, 0.803921640f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 Blue = { { { 0.f, 0.f, 1.f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 BlueViolet = { { { 0.541176498f, 0.168627456f, 0.886274576f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 Brown = { { { 0.647058845f, 0.164705887f, 0.164705887f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 BurlyWood = { { { 0.870588303f, 0.721568644f, 0.529411793f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 CadetBlue = { { { 0.372549027f, 0.619607866f, 0.627451003f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 Chartreuse = { { { 0.498039246f, 1.f, 0.f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 Chocolate = { { { 0.823529482f, 0.411764741f, 0.117647067f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 Coral = { { { 1.f, 0.498039246f, 0.313725501f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 CornflowerBlue = { { { 0.392156899f, 0.584313750f, 0.929411829f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 Cornsilk = { { { 1.f, 0.972549081f, 0.862745166f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 Crimson = { { { 0.862745166f, 0.078431375f, 0.235294133f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 Cyan = { { { 0.f, 1.f, 1.f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 DarkBlue = { { { 0.f, 0.f, 0.545098066f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 DarkCyan = { { { 0.f, 0.545098066f, 0.545098066f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 DarkGoldenrod = { { { 0.721568644f, 0.525490224f, 0.043137256f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 DarkGray = { { { 0.662745118f, 0.662745118f, 0.662745118f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 DarkGreen = { { { 0.f, 0.392156899f, 0.f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 DarkKhaki = { { { 0.741176486f, 0.717647076f, 0.419607878f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 DarkMagenta = { { { 0.545098066f, 0.f, 0.545098066f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 DarkOliveGreen = { { { 0.333333343f, 0.419607878f, 0.184313729f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 DarkOrange = { { { 1.f, 0.549019635f, 0.f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 DarkOrchid = { { { 0.600000024f, 0.196078449f, 0.800000072f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 DarkRed = { { { 0.545098066f, 0.f, 0.f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 DarkSalmon = { { { 0.913725555f, 0.588235319f, 0.478431404f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 DarkSeaGreen = { { { 0.560784340f, 0.737254918f, 0.545098066f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 DarkSlateBlue = { { { 0.282352954f, 0.239215702f, 0.545098066f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 DarkSlateGray = { { { 0.184313729f, 0.309803933f, 0.309803933f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 DarkTurquoise = { { { 0.f, 0.807843208f, 0.819607913f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 DarkViolet = { { { 0.580392182f, 0.f, 0.827451050f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 DeepPink = { { { 1.f, 0.078431375f, 0.576470613f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 DeepSkyBlue = { { { 0.f, 0.749019623f, 1.f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 DimGray = { { { 0.411764741f, 0.411764741f, 0.411764741f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 DodgerBlue = { { { 0.117647067f, 0.564705908f, 1.f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 Firebrick = { { { 0.698039234f, 0.133333340f, 0.133333340f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 FloralWhite = { { { 1.f, 0.980392218f, 0.941176534f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 ForestGreen = { { { 0.133333340f, 0.545098066f, 0.133333340f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 Fuchsia = { { { 1.f, 0.f, 1.f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 Gainsboro = { { { 0.862745166f, 0.862745166f, 0.862745166f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 GhostWhite = { { { 0.972549081f, 0.972549081f, 1.f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 Gold = { { { 1.f, 0.843137324f, 0.f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 Goldenrod = { { { 0.854902029f, 0.647058845f, 0.125490203f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 Gray = { { { 0.501960814f, 0.501960814f, 0.501960814f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 Green = { { { 0.f, 0.501960814f, 0.f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 GreenYellow = { { { 0.678431392f, 1.f, 0.184313729f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 Honeydew = { { { 0.941176534f, 1.f, 0.941176534f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 HotPink = { { { 1.f, 0.411764741f, 0.705882370f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 IndianRed = { { { 0.803921640f, 0.360784322f, 0.360784322f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 Indigo = { { { 0.294117659f, 0.f, 0.509803951f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 Ivory = { { { 1.f, 1.f, 0.941176534f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 Khaki = { { { 0.941176534f, 0.901960850f, 0.549019635f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 Lavender = { { { 0.901960850f, 0.901960850f, 0.980392218f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 LavenderBlush = { { { 1.f, 0.941176534f, 0.960784376f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 LawnGreen = { { { 0.486274540f, 0.988235354f, 0.f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 LemonChiffon = { { { 1.f, 0.980392218f, 0.803921640f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 LightBlue = { { { 0.678431392f, 0.847058892f, 0.901960850f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 LightCoral = { { { 0.941176534f, 0.501960814f, 0.501960814f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 LightCyan = { { { 0.878431439f, 1.f, 1.f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 LightGoldenrodYellow = { { { 0.980392218f, 0.980392218f, 0.823529482f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 LightGray = { { { 0.827451050f, 0.827451050f, 0.827451050f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 LightGreen = { { { 0.564705908f, 0.933333397f, 0.564705908f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 LightPink = { { { 1.f, 0.713725507f, 0.756862819f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 LightSalmon = { { { 1.f, 0.627451003f, 0.478431404f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 LightSeaGreen = { { { 0.125490203f, 0.698039234f, 0.666666687f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 LightSkyBlue = { { { 0.529411793f, 0.807843208f, 0.980392218f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 LightSlateGray = { { { 0.466666698f, 0.533333361f, 0.600000024f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 LightSteelBlue = { { { 0.690196097f, 0.768627524f, 0.870588303f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 LightYellow = { { { 1.f, 1.f, 0.878431439f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 Lime = { { { 0.f, 1.f, 0.f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 LimeGreen = { { { 0.196078449f, 0.803921640f, 0.196078449f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 Linen = { { { 0.980392218f, 0.941176534f, 0.901960850f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 Magenta = { { { 1.f, 0.f, 1.f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 Maroon = { { { 0.501960814f, 0.f, 0.f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 MediumAquamarine = { { { 0.400000036f, 0.803921640f, 0.666666687f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 MediumBlue = { { { 0.f, 0.f, 0.803921640f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 MediumOrchid = { { { 0.729411781f, 0.333333343f, 0.827451050f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 MediumPurple = { { { 0.576470613f, 0.439215720f, 0.858823597f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 MediumSeaGreen = { { { 0.235294133f, 0.701960802f, 0.443137288f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 MediumSlateBlue = { { { 0.482352972f, 0.407843173f, 0.933333397f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 MediumSpringGreen = { { { 0.f, 0.980392218f, 0.603921592f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 MediumTurquoise = { { { 0.282352954f, 0.819607913f, 0.800000072f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 MediumVioletRed = { { { 0.780392230f, 0.082352944f, 0.521568656f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 MidnightBlue = { { { 0.098039225f, 0.098039225f, 0.439215720f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 MintCream = { { { 0.960784376f, 1.f, 0.980392218f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 MistyRose = { { { 1.f, 0.894117713f, 0.882353008f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 Moccasin = { { { 1.f, 0.894117713f, 0.709803939f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 NavajoWhite = { { { 1.f, 0.870588303f, 0.678431392f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 Navy = { { { 0.f, 0.f, 0.501960814f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 OldLace = { { { 0.992156923f, 0.960784376f, 0.901960850f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 Olive = { { { 0.501960814f, 0.501960814f, 0.f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 OliveDrab = { { { 0.419607878f, 0.556862772f, 0.137254909f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 Orange = { { { 1.f, 0.647058845f, 0.f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 OrangeRed = { { { 1.f, 0.270588249f, 0.f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 Orchid = { { { 0.854902029f, 0.439215720f, 0.839215755f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 PaleGoldenrod = { { { 0.933333397f, 0.909803987f, 0.666666687f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 PaleGreen = { { { 0.596078455f, 0.984313786f, 0.596078455f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 PaleTurquoise = { { { 0.686274529f, 0.933333397f, 0.933333397f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 PaleVioletRed = { { { 0.858823597f, 0.439215720f, 0.576470613f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 PapayaWhip = { { { 1.f, 0.937254965f, 0.835294187f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 PeachPuff = { { { 1.f, 0.854902029f, 0.725490212f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 Peru = { { { 0.803921640f, 0.521568656f, 0.247058839f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 Pink = { { { 1.f, 0.752941251f, 0.796078503f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 Plum = { { { 0.866666734f, 0.627451003f, 0.866666734f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 PowderBlue = { { { 0.690196097f, 0.878431439f, 0.901960850f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 Purple = { { { 0.501960814f, 0.f, 0.501960814f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 Red = { { { 1.f, 0.f, 0.f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 RosyBrown = { { { 0.737254918f, 0.560784340f, 0.560784340f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 RoyalBlue = { { { 0.254901975f, 0.411764741f, 0.882353008f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 SaddleBrown = { { { 0.545098066f, 0.270588249f, 0.074509807f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 Salmon = { { { 0.980392218f, 0.501960814f, 0.447058856f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 SandyBrown = { { { 0.956862807f, 0.643137276f, 0.376470625f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 SeaGreen = { { { 0.180392161f, 0.545098066f, 0.341176480f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 SeaShell = { { { 1.f, 0.960784376f, 0.933333397f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 Sienna = { { { 0.627451003f, 0.321568638f, 0.176470593f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 Silver = { { { 0.752941251f, 0.752941251f, 0.752941251f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 SkyBlue = { { { 0.529411793f, 0.807843208f, 0.921568692f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 SlateBlue = { { { 0.415686309f, 0.352941185f, 0.803921640f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 SlateGray = { { { 0.439215720f, 0.501960814f, 0.564705908f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 Snow = { { { 1.f, 0.980392218f, 0.980392218f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 SpringGreen = { { { 0.f, 1.f, 0.498039246f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 SteelBlue = { { { 0.274509817f, 0.509803951f, 0.705882370f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 Tan = { { { 0.823529482f, 0.705882370f, 0.549019635f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 Teal = { { { 0.f, 0.501960814f, 0.501960814f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 Thistle = { { { 0.847058892f, 0.749019623f, 0.847058892f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 Tomato = { { { 1.f, 0.388235331f, 0.278431386f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 Transparent = { { { 0.f, 0.f, 0.f, 0.f } } };
+        XMGLOBALCONST XMVECTORF32 Turquoise = { { { 0.250980407f, 0.878431439f, 0.815686345f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 Violet = { { { 0.933333397f, 0.509803951f, 0.933333397f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 Wheat = { { { 0.960784376f, 0.870588303f, 0.701960802f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 White = { { { 1.f, 1.f, 1.f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 WhiteSmoke = { { { 0.960784376f, 0.960784376f, 0.960784376f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 Yellow = { { { 1.f, 1.f, 0.f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 YellowGreen = { { { 0.603921592f, 0.803921640f, 0.196078449f, 1.f } } };
+
+    } // namespace Colors
+
+    namespace ColorsLinear
+    {
+        // Standard colors (Red/Green/Blue/Alpha) in linear colorspace
+        XMGLOBALCONST XMVECTORF32 AliceBlue = { { { 0.871367335f, 0.938685894f, 1.f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 AntiqueWhite = { { { 0.955973506f, 0.830770075f, 0.679542601f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 Aqua = { { { 0.f, 1.f, 1.f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 Aquamarine = { { { 0.212230787f, 1.f, 0.658374965f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 Azure = { { { 0.871367335f, 1.f, 1.f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 Beige = { { { 0.913098991f, 0.913098991f, 0.715693772f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 Bisque = { { { 1.f, 0.775822461f, 0.552011609f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 Black = { { { 0.f, 0.f, 0.f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 BlanchedAlmond = { { { 1.f, 0.830770075f, 0.610495746f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 Blue = { { { 0.f, 0.f, 1.f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 BlueViolet = { { { 0.254152179f, 0.024157630f, 0.760524750f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 Brown = { { { 0.376262218f, 0.023153365f, 0.023153365f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 BurlyWood = { { { 0.730461001f, 0.479320228f, 0.242281199f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 CadetBlue = { { { 0.114435382f, 0.341914445f, 0.351532698f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 Chartreuse = { { { 0.212230787f, 1.f, 0.f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 Chocolate = { { { 0.644479871f, 0.141263321f, 0.012983031f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 Coral = { { { 1.f, 0.212230787f, 0.080219828f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 CornflowerBlue = { { { 0.127437726f, 0.300543845f, 0.846873462f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 Cornsilk = { { { 1.f, 0.938685894f, 0.715693772f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 Crimson = { { { 0.715693772f, 0.006995410f, 0.045186214f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 Cyan = { { { 0.f, 1.f, 1.f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 DarkBlue = { { { 0.f, 0.f, 0.258182913f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 DarkCyan = { { { 0.f, 0.258182913f, 0.258182913f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 DarkGoldenrod = { { { 0.479320228f, 0.238397658f, 0.003346536f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 DarkGray = { { { 0.396755308f, 0.396755308f, 0.396755308f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 DarkGreen = { { { 0.f, 0.127437726f, 0.f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 DarkKhaki = { { { 0.508881450f, 0.473531544f, 0.147027299f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 DarkMagenta = { { { 0.258182913f, 0.f, 0.258182913f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 DarkOliveGreen = { { { 0.090841733f, 0.147027299f, 0.028426038f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 DarkOrange = { { { 1.f, 0.262250721f, 0.f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 DarkOrchid = { { { 0.318546832f, 0.031896040f, 0.603827536f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 DarkRed = { { { 0.258182913f, 0.f, 0.f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 DarkSalmon = { { { 0.814846814f, 0.304987371f, 0.194617867f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 DarkSeaGreen = { { { 0.274677366f, 0.502886593f, 0.258182913f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 DarkSlateBlue = { { { 0.064803280f, 0.046665095f, 0.258182913f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 DarkSlateGray = { { { 0.028426038f, 0.078187428f, 0.078187428f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 DarkTurquoise = { { { 0.f, 0.617206752f, 0.637597024f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 DarkViolet = { { { 0.296138316f, 0.f, 0.651405811f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 DeepPink = { { { 1.f, 0.006995410f, 0.291770697f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 DeepSkyBlue = { { { 0.f, 0.520995677f, 1.f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 DimGray = { { { 0.141263321f, 0.141263321f, 0.141263321f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 DodgerBlue = { { { 0.012983031f, 0.278894335f, 1.f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 Firebrick = { { { 0.445201248f, 0.015996292f, 0.015996292f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 FloralWhite = { { { 1.f, 0.955973506f, 0.871367335f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 ForestGreen = { { { 0.015996292f, 0.258182913f, 0.015996292f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 Fuchsia = { { { 1.f, 0.f, 1.f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 Gainsboro = { { { 0.715693772f, 0.715693772f, 0.715693772f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 GhostWhite = { { { 0.938685894f, 0.938685894f, 1.f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 Gold = { { { 1.f, 0.679542601f, 0.f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 Goldenrod = { { { 0.701102138f, 0.376262218f, 0.014443844f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 Gray = { { { 0.215860531f, 0.215860531f, 0.215860531f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 Green = { { { 0.f, 0.215860531f, 0.f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 GreenYellow = { { { 0.417885154f, 1.f, 0.028426038f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 Honeydew = { { { 0.871367335f, 1.f, 0.871367335f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 HotPink = { { { 1.f, 0.141263321f, 0.456411064f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 IndianRed = { { { 0.610495746f, 0.107023112f, 0.107023112f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 Indigo = { { { 0.070360109f, 0.f, 0.223227978f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 Ivory = { { { 1.f, 1.f, 0.871367335f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 Khaki = { { { 0.871367335f, 0.791298151f, 0.262250721f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 Lavender = { { { 0.791298151f, 0.791298151f, 0.955973506f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 LavenderBlush = { { { 1.f, 0.871367335f, 0.913098991f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 LawnGreen = { { { 0.201556295f, 0.973445475f, 0.f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 LemonChiffon = { { { 1.f, 0.955973506f, 0.610495746f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 LightBlue = { { { 0.417885154f, 0.686685443f, 0.791298151f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 LightCoral = { { { 0.871367335f, 0.215860531f, 0.215860531f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 LightCyan = { { { 0.745404482f, 1.f, 1.f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 LightGoldenrodYellow = { { { 0.955973506f, 0.955973506f, 0.644479871f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 LightGray = { { { 0.651405811f, 0.651405811f, 0.651405811f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 LightGreen = { { { 0.278894335f, 0.854992807f, 0.278894335f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 LightPink = { { { 1.f, 0.467783839f, 0.533276618f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 LightSalmon = { { { 1.f, 0.351532698f, 0.194617867f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 LightSeaGreen = { { { 0.014443844f, 0.445201248f, 0.401977867f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 LightSkyBlue = { { { 0.242281199f, 0.617206752f, 0.955973506f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 LightSlateGray = { { { 0.184475034f, 0.246201396f, 0.318546832f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 LightSteelBlue = { { { 0.434153706f, 0.552011609f, 0.730461001f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 LightYellow = { { { 1.f, 1.f, 0.745404482f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 Lime = { { { 0.f, 1.f, 0.f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 LimeGreen = { { { 0.031896040f, 0.610495746f, 0.031896040f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 Linen = { { { 0.955973506f, 0.871367335f, 0.791298151f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 Magenta = { { { 1.f, 0.f, 1.f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 Maroon = { { { 0.215860531f, 0.f, 0.f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 MediumAquamarine = { { { 0.132868364f, 0.610495746f, 0.401977867f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 MediumBlue = { { { 0.f, 0.f, 0.610495746f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 MediumOrchid = { { { 0.491020888f, 0.090841733f, 0.651405811f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 MediumPurple = { { { 0.291770697f, 0.162029430f, 0.708376050f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 MediumSeaGreen = { { { 0.045186214f, 0.450785846f, 0.165132239f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 MediumSlateBlue = { { { 0.198069349f, 0.138431653f, 0.854992807f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 MediumSpringGreen = { { { 0.f, 0.955973506f, 0.323143244f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 MediumTurquoise = { { { 0.064803280f, 0.637597024f, 0.603827536f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 MediumVioletRed = { { { 0.571125031f, 0.007499032f, 0.234550655f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 MidnightBlue = { { { 0.009721218f, 0.009721218f, 0.162029430f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 MintCream = { { { 0.913098991f, 1.f, 0.955973506f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 MistyRose = { { { 1.f, 0.775822461f, 0.752942443f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 Moccasin = { { { 1.f, 0.775822461f, 0.462077051f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 NavajoWhite = { { { 1.f, 0.730461001f, 0.417885154f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 Navy = { { { 0.f, 0.f, 0.215860531f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 OldLace = { { { 0.982250869f, 0.913098991f, 0.791298151f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 Olive = { { { 0.215860531f, 0.215860531f, 0.f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 OliveDrab = { { { 0.147027299f, 0.270497859f, 0.016807375f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 Orange = { { { 1.f, 0.376262218f, 0.f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 OrangeRed = { { { 1.f, 0.059511241f, 0.f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 Orchid = { { { 0.701102138f, 0.162029430f, 0.672443330f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 PaleGoldenrod = { { { 0.854992807f, 0.806952477f, 0.401977867f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 PaleGreen = { { { 0.313988745f, 0.964686573f, 0.313988745f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 PaleTurquoise = { { { 0.428690553f, 0.854992807f, 0.854992807f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 PaleVioletRed = { { { 0.708376050f, 0.162029430f, 0.291770697f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 PapayaWhip = { { { 1.f, 0.863157392f, 0.665387452f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 PeachPuff = { { { 1.f, 0.701102138f, 0.485149980f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 Peru = { { { 0.610495746f, 0.234550655f, 0.049706575f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 Pink = { { { 1.f, 0.527115345f, 0.597202003f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 Plum = { { { 0.723055363f, 0.351532698f, 0.723055363f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 PowderBlue = { { { 0.434153706f, 0.745404482f, 0.791298151f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 Purple = { { { 0.215860531f, 0.f, 0.215860531f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 Red = { { { 1.f, 0.f, 0.f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 RosyBrown = { { { 0.502886593f, 0.274677366f, 0.274677366f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 RoyalBlue = { { { 0.052860655f, 0.141263321f, 0.752942443f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 SaddleBrown = { { { 0.258182913f, 0.059511241f, 0.006512091f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 Salmon = { { { 0.955973506f, 0.215860531f, 0.168269455f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 SandyBrown = { { { 0.904661357f, 0.371237785f, 0.116970696f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 SeaGreen = { { { 0.027320892f, 0.258182913f, 0.095307484f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 SeaShell = { { { 1.f, 0.913098991f, 0.854992807f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 Sienna = { { { 0.351532698f, 0.084376216f, 0.026241222f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 Silver = { { { 0.527115345f, 0.527115345f, 0.527115345f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 SkyBlue = { { { 0.242281199f, 0.617206752f, 0.830770075f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 SlateBlue = { { { 0.144128501f, 0.102241747f, 0.610495746f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 SlateGray = { { { 0.162029430f, 0.215860531f, 0.278894335f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 Snow = { { { 1.f, 0.955973506f, 0.955973506f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 SpringGreen = { { { 0.f, 1.f, 0.212230787f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 SteelBlue = { { { 0.061246071f, 0.223227978f, 0.456411064f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 Tan = { { { 0.644479871f, 0.456411064f, 0.262250721f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 Teal = { { { 0.f, 0.215860531f, 0.215860531f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 Thistle = { { { 0.686685443f, 0.520995677f, 0.686685443f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 Tomato = { { { 1.f, 0.124771863f, 0.063010029f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 Transparent = { { { 0.f, 0.f, 0.f, 0.f } } };
+        XMGLOBALCONST XMVECTORF32 Turquoise = { { { 0.051269468f, 0.745404482f, 0.630757332f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 Violet = { { { 0.854992807f, 0.223227978f, 0.854992807f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 Wheat = { { { 0.913098991f, 0.730461001f, 0.450785846f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 White = { { { 1.f, 1.f, 1.f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 WhiteSmoke = { { { 0.913098991f, 0.913098991f, 0.913098991f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 Yellow = { { { 1.f, 1.f, 0.f, 1.f } } };
+        XMGLOBALCONST XMVECTORF32 YellowGreen = { { { 0.323143244f, 0.610495746f, 0.031896040f, 1.f } } };
+
+    } // namespace ColorsLinear
+
+} // namespace DirectX
+

EscapeTheBackroomsGUiTest/vcpkg_Out/include/dxguids/dxguids.h

@@ -0,0 +1,195 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+#pragma once
+
+#ifndef __cplusplus
+#error "This header requires C++"
+#endif
+
+constexpr inline bool ConstexprIsEqualGUID(REFGUID a, REFGUID b)
+{
+    return a.Data1 == b.Data1 &&
+        a.Data2 == b.Data2 &&
+        a.Data3 == b.Data3 &&
+        a.Data4[0] == b.Data4[0] &&
+        a.Data4[1] == b.Data4[1] &&
+        a.Data4[2] == b.Data4[2] &&
+        a.Data4[3] == b.Data4[3] &&
+        a.Data4[4] == b.Data4[4] &&
+        a.Data4[5] == b.Data4[5] &&
+        a.Data4[6] == b.Data4[6] &&
+        a.Data4[7] == b.Data4[7];
+}
+
+template <typename T> GUID uuidof() = delete;
+template <typename T> GUID uuidof(T*) { return uuidof<T>(); }
+template <typename T> GUID uuidof(T**) { return uuidof<T>(); }
+template <typename T> GUID uuidof(T&) { return uuidof<T>(); }
+
+// Each COM interface (e.g. ID3D12Device) has a unique interface ID (IID) associated with it. With MSVC, the IID is defined 
+// along with the interface declaration using compiler intrinsics (__declspec(uuid(...)); the IID can then be retrieved 
+// using __uuidof. These intrinsics are not supported with all toolchains, so these helpers redefine IID values that can be 
+// used with the various adapter COM helpers (ComPtr, IID_PPV_ARGS, etc.) for Linux. IIDs are stable and cannot change, but as 
+// a precaution we statically assert the values are as expected when compiling for Windows.
+#if defined(_MSC_VER)
+#define _DXGUIDS_SUPPORT_STATIC_ASSERT_IID
+#elif defined(__CRT_UUID_DECL)
+/* match _mingw.h */
+#if __cpp_constexpr >= 200704l && __cpp_inline_variables >= 201606L
+#define _DXGUIDS_SUPPORT_STATIC_ASSERT_IID
+#endif /* __cpp_constexpr >= 200704l && __cpp_inline_variables >= 201606L */
+#endif /* _MSC_VER */
+
+#ifdef _DXGUIDS_SUPPORT_STATIC_ASSERT_IID
+#define _WINADAPTER_ASSERT_IID(InterfaceName) \
+static_assert(ConstexprIsEqualGUID(uuidof<InterfaceName>(), __uuidof(InterfaceName)), "GUID definition mismatch: "#InterfaceName);
+#else
+#define _WINADAPTER_ASSERT_IID(InterfaceName)
+#endif
+
+#ifdef __CRT_UUID_DECL
+#define WINADAPTER_IID(InterfaceName, l, w1, w2, b1, b2, b3, b4, b5, b6, b7, b8) \
+template <> constexpr GUID uuidof<InterfaceName>() \
+{ \
+    return { l, w1, w2, { b1, b2,  b3,  b4,  b5,  b6,  b7,  b8 } }; \
+} \
+__CRT_UUID_DECL(InterfaceName, l, w1, w2, b1, b2, b3, b4, b5, b6, b7, b8) \
+_WINADAPTER_ASSERT_IID(InterfaceName)
+#else
+#define WINADAPTER_IID(InterfaceName, l, w1, w2, b1, b2, b3, b4, b5, b6, b7, b8) \
+template <> constexpr GUID uuidof<InterfaceName>() \
+{ \
+    return { l, w1, w2, { b1, b2,  b3,  b4,  b5,  b6,  b7,  b8 } }; \
+} \
+_WINADAPTER_ASSERT_IID(InterfaceName)
+#endif /* defined(_WIN32) && defined(__MINGW32__) */
+
+// Direct3D
+#ifdef __d3d12_h__
+WINADAPTER_IID(ID3D12Object, 0xc4fec28f, 0x7966, 0x4e95, 0x9f, 0x94, 0xf4, 0x31, 0xcb, 0x56, 0xc3, 0xb8);
+WINADAPTER_IID(ID3D12DeviceChild, 0x905db94b, 0xa00c, 0x4140, 0x9d, 0xf5, 0x2b, 0x64, 0xca, 0x9e, 0xa3, 0x57);
+WINADAPTER_IID(ID3D12RootSignature, 0xc54a6b66, 0x72df, 0x4ee8, 0x8b, 0xe5, 0xa9, 0x46, 0xa1, 0x42, 0x92, 0x14);
+WINADAPTER_IID(ID3D12RootSignatureDeserializer, 0x34AB647B, 0x3CC8, 0x46AC, 0x84, 0x1B, 0xC0, 0x96, 0x56, 0x45, 0xC0, 0x46);
+WINADAPTER_IID(ID3D12VersionedRootSignatureDeserializer, 0x7F91CE67, 0x090C, 0x4BB7, 0xB7, 0x8E, 0xED, 0x8F, 0xF2, 0xE3, 0x1D, 0xA0);
+WINADAPTER_IID(ID3D12Pageable, 0x63ee58fb, 0x1268, 0x4835, 0x86, 0xda, 0xf0, 0x08, 0xce, 0x62, 0xf0, 0xd6);
+WINADAPTER_IID(ID3D12Heap, 0x6b3b2502, 0x6e51, 0x45b3, 0x90, 0xee, 0x98, 0x84, 0x26, 0x5e, 0x8d, 0xf3);
+WINADAPTER_IID(ID3D12Resource, 0x696442be, 0xa72e, 0x4059, 0xbc, 0x79, 0x5b, 0x5c, 0x98, 0x04, 0x0f, 0xad);
+WINADAPTER_IID(ID3D12CommandAllocator, 0x6102dee4, 0xaf59, 0x4b09, 0xb9, 0x99, 0xb4, 0x4d, 0x73, 0xf0, 0x9b, 0x24);
+WINADAPTER_IID(ID3D12Fence, 0x0a753dcf, 0xc4d8, 0x4b91, 0xad, 0xf6, 0xbe, 0x5a, 0x60, 0xd9, 0x5a, 0x76);
+WINADAPTER_IID(ID3D12Fence1, 0x433685fe, 0xe22b, 0x4ca0, 0xa8, 0xdb, 0xb5, 0xb4, 0xf4, 0xdd, 0x0e, 0x4a);
+WINADAPTER_IID(ID3D12PipelineState, 0x765a30f3, 0xf624, 0x4c6f, 0xa8, 0x28, 0xac, 0xe9, 0x48, 0x62, 0x24, 0x45);
+WINADAPTER_IID(ID3D12DescriptorHeap, 0x8efb471d, 0x616c, 0x4f49, 0x90, 0xf7, 0x12, 0x7b, 0xb7, 0x63, 0xfa, 0x51);
+WINADAPTER_IID(ID3D12QueryHeap, 0x0d9658ae, 0xed45, 0x469e, 0xa6, 0x1d, 0x97, 0x0e, 0xc5, 0x83, 0xca, 0xb4);
+WINADAPTER_IID(ID3D12CommandSignature, 0xc36a797c, 0xec80, 0x4f0a, 0x89, 0x85, 0xa7, 0xb2, 0x47, 0x50, 0x82, 0xd1);
+WINADAPTER_IID(ID3D12CommandList, 0x7116d91c, 0xe7e4, 0x47ce, 0xb8, 0xc6, 0xec, 0x81, 0x68, 0xf4, 0x37, 0xe5);
+WINADAPTER_IID(ID3D12GraphicsCommandList, 0x5b160d0f, 0xac1b, 0x4185, 0x8b, 0xa8, 0xb3, 0xae, 0x42, 0xa5, 0xa4, 0x55);
+WINADAPTER_IID(ID3D12GraphicsCommandList1, 0x553103fb, 0x1fe7, 0x4557, 0xbb, 0x38, 0x94, 0x6d, 0x7d, 0x0e, 0x7c, 0xa7);
+WINADAPTER_IID(ID3D12GraphicsCommandList2, 0x38C3E585, 0xFF17, 0x412C, 0x91, 0x50, 0x4F, 0xC6, 0xF9, 0xD7, 0x2A, 0x28);
+WINADAPTER_IID(ID3D12CommandQueue, 0x0ec870a6, 0x5d7e, 0x4c22, 0x8c, 0xfc, 0x5b, 0xaa, 0xe0, 0x76, 0x16, 0xed);
+WINADAPTER_IID(ID3D12Device, 0x189819f1, 0x1db6, 0x4b57, 0xbe, 0x54, 0x18, 0x21, 0x33, 0x9b, 0x85, 0xf7);
+WINADAPTER_IID(ID3D12PipelineLibrary, 0xc64226a8, 0x9201, 0x46af, 0xb4, 0xcc, 0x53, 0xfb, 0x9f, 0xf7, 0x41, 0x4f);
+WINADAPTER_IID(ID3D12PipelineLibrary1, 0x80eabf42, 0x2568, 0x4e5e, 0xbd, 0x82, 0xc3, 0x7f, 0x86, 0x96, 0x1d, 0xc3);
+WINADAPTER_IID(ID3D12Device1, 0x77acce80, 0x638e, 0x4e65, 0x88, 0x95, 0xc1, 0xf2, 0x33, 0x86, 0x86, 0x3e);
+WINADAPTER_IID(ID3D12Device2, 0x30baa41e, 0xb15b, 0x475c, 0xa0, 0xbb, 0x1a, 0xf5, 0xc5, 0xb6, 0x43, 0x28);
+WINADAPTER_IID(ID3D12Device3, 0x81dadc15, 0x2bad, 0x4392, 0x93, 0xc5, 0x10, 0x13, 0x45, 0xc4, 0xaa, 0x98);
+WINADAPTER_IID(ID3D12ProtectedSession, 0xA1533D18, 0x0AC1, 0x4084, 0x85, 0xB9, 0x89, 0xA9, 0x61, 0x16, 0x80, 0x6B);
+WINADAPTER_IID(ID3D12ProtectedResourceSession, 0x6CD696F4, 0xF289, 0x40CC, 0x80, 0x91, 0x5A, 0x6C, 0x0A, 0x09, 0x9C, 0x3D);
+WINADAPTER_IID(ID3D12Device4, 0xe865df17, 0xa9ee, 0x46f9, 0xa4, 0x63, 0x30, 0x98, 0x31, 0x5a, 0xa2, 0xe5);
+WINADAPTER_IID(ID3D12LifetimeOwner, 0xe667af9f, 0xcd56, 0x4f46, 0x83, 0xce, 0x03, 0x2e, 0x59, 0x5d, 0x70, 0xa8);
+WINADAPTER_IID(ID3D12SwapChainAssistant, 0xf1df64b6, 0x57fd, 0x49cd, 0x88, 0x07, 0xc0, 0xeb, 0x88, 0xb4, 0x5c, 0x8f);
+WINADAPTER_IID(ID3D12LifetimeTracker, 0x3fd03d36, 0x4eb1, 0x424a, 0xa5, 0x82, 0x49, 0x4e, 0xcb, 0x8b, 0xa8, 0x13);
+WINADAPTER_IID(ID3D12StateObject, 0x47016943, 0xfca8, 0x4594, 0x93, 0xea, 0xaf, 0x25, 0x8b, 0x55, 0x34, 0x6d);
+WINADAPTER_IID(ID3D12StateObjectProperties, 0xde5fa827, 0x9bf9, 0x4f26, 0x89, 0xff, 0xd7, 0xf5, 0x6f, 0xde, 0x38, 0x60);
+WINADAPTER_IID(ID3D12Device5, 0x8b4f173b, 0x2fea, 0x4b80, 0x8f, 0x58, 0x43, 0x07, 0x19, 0x1a, 0xb9, 0x5d);
+WINADAPTER_IID(ID3D12DeviceRemovedExtendedDataSettings, 0x82BC481C, 0x6B9B, 0x4030, 0xAE, 0xDB, 0x7E, 0xE3, 0xD1, 0xDF, 0x1E, 0x63);
+WINADAPTER_IID(ID3D12DeviceRemovedExtendedDataSettings1, 0xDBD5AE51, 0x3317, 0x4F0A, 0xAD, 0xF9, 0x1D, 0x7C, 0xED, 0xCA, 0xAE, 0x0B);
+WINADAPTER_IID(ID3D12DeviceRemovedExtendedDataSettings2, 0x61552388, 0x01ab, 0x4008, 0xa4, 0x36, 0x83, 0xdb, 0x18, 0x95, 0x66, 0xea);
+WINADAPTER_IID(ID3D12DeviceRemovedExtendedData, 0x98931D33, 0x5AE8, 0x4791, 0xAA, 0x3C, 0x1A, 0x73, 0xA2, 0x93, 0x4E, 0x71);
+WINADAPTER_IID(ID3D12DeviceRemovedExtendedData1, 0x9727A022, 0xCF1D, 0x4DDA, 0x9E, 0xBA, 0xEF, 0xFA, 0x65, 0x3F, 0xC5, 0x06);
+WINADAPTER_IID(ID3D12DeviceRemovedExtendedData2, 0x67FC5816, 0xE4CA, 0x4915, 0xBF, 0x18, 0x42, 0x54, 0x12, 0x72, 0xDA, 0x54);
+WINADAPTER_IID(ID3D12Device6, 0xc70b221b, 0x40e4, 0x4a17, 0x89, 0xaf, 0x02, 0x5a, 0x07, 0x27, 0xa6, 0xdc);
+WINADAPTER_IID(ID3D12ProtectedResourceSession1, 0xD6F12DD6, 0x76FB, 0x406E, 0x89, 0x61, 0x42, 0x96, 0xEE, 0xFC, 0x04, 0x09);
+WINADAPTER_IID(ID3D12Device7, 0x5c014b53, 0x68a1, 0x4b9b, 0x8b, 0xd1, 0xdd, 0x60, 0x46, 0xb9, 0x35, 0x8b);
+WINADAPTER_IID(ID3D12Device8, 0x9218E6BB, 0xF944, 0x4F7E, 0xA7, 0x5C, 0xB1, 0xB2, 0xC7, 0xB7, 0x01, 0xF3);
+WINADAPTER_IID(ID3D12Resource1, 0x9D5E227A, 0x4430, 0x4161, 0x88, 0xB3, 0x3E, 0xCA, 0x6B, 0xB1, 0x6E, 0x19);
+WINADAPTER_IID(ID3D12Resource2, 0xBE36EC3B, 0xEA85, 0x4AEB, 0xA4, 0x5A, 0xE9, 0xD7, 0x64, 0x04, 0xA4, 0x95);
+WINADAPTER_IID(ID3D12Heap1, 0x572F7389, 0x2168, 0x49E3, 0x96, 0x93, 0xD6, 0xDF, 0x58, 0x71, 0xBF, 0x6D);
+WINADAPTER_IID(ID3D12GraphicsCommandList3, 0x6FDA83A7, 0xB84C, 0x4E38, 0x9A, 0xC8, 0xC7, 0xBD, 0x22, 0x01, 0x6B, 0x3D);
+WINADAPTER_IID(ID3D12MetaCommand, 0xDBB84C27, 0x36CE, 0x4FC9, 0xB8, 0x01, 0xF0, 0x48, 0xC4, 0x6A, 0xC5, 0x70);
+WINADAPTER_IID(ID3D12GraphicsCommandList4, 0x8754318e, 0xd3a9, 0x4541, 0x98, 0xcf, 0x64, 0x5b, 0x50, 0xdc, 0x48, 0x74);
+WINADAPTER_IID(ID3D12ShaderCacheSession, 0x28e2495d, 0x0f64, 0x4ae4, 0xa6, 0xec, 0x12, 0x92, 0x55, 0xdc, 0x49, 0xa8);
+WINADAPTER_IID(ID3D12Device9, 0x4c80e962, 0xf032, 0x4f60, 0xbc, 0x9e, 0xeb, 0xc2, 0xcf, 0xa1, 0xd8, 0x3c);
+WINADAPTER_IID(ID3D12Device10, 0x517f8718, 0xaa66, 0x49f9, 0xb0, 0x2b, 0xa7, 0xab, 0x89, 0xc0, 0x60, 0x31);
+WINADAPTER_IID(ID3D12Device11, 0x5405c344, 0xd457, 0x444e, 0xb4, 0xdd, 0x23, 0x66, 0xe4, 0x5a, 0xee, 0x39);
+WINADAPTER_IID(ID3D12VirtualizationGuestDevice, 0xbc66d368, 0x7373, 0x4943, 0x87, 0x57, 0xfc, 0x87, 0xdc, 0x79, 0xe4, 0x76);
+WINADAPTER_IID(ID3D12Tools, 0x7071e1f0, 0xe84b, 0x4b33, 0x97, 0x4f, 0x12, 0xfa, 0x49, 0xde, 0x65, 0xc5);
+WINADAPTER_IID(ID3D12SDKConfiguration, 0xe9eb5314, 0x33aa, 0x42b2, 0xa7, 0x18, 0xd7, 0x7f, 0x58, 0xb1, 0xf1, 0xc7);
+WINADAPTER_IID(ID3D12SDKConfiguration1, 0x8aaf9303, 0xad25, 0x48b9, 0x9a, 0x57, 0xd9, 0xc3, 0x7e, 0x00, 0x9d, 0x9f);
+WINADAPTER_IID(ID3D12DeviceFactory, 0x61f307d3, 0xd34e, 0x4e7c, 0x83, 0x74, 0x3b, 0xa4, 0xde, 0x23, 0xcc, 0xcb);
+WINADAPTER_IID(ID3D12DeviceConfiguration, 0x78dbf87b, 0xf766, 0x422b, 0xa6, 0x1c, 0xc8, 0xc4, 0x46, 0xbd, 0xb9, 0xad);
+WINADAPTER_IID(ID3D12GraphicsCommandList5, 0x55050859, 0x4024, 0x474c, 0x87, 0xf5, 0x64, 0x72, 0xea, 0xee, 0x44, 0xea);
+WINADAPTER_IID(ID3D12GraphicsCommandList6, 0xc3827890, 0xe548, 0x4cfa, 0x96, 0xcf, 0x56, 0x89, 0xa9, 0x37, 0x0f, 0x80);
+WINADAPTER_IID(ID3D12GraphicsCommandList7, 0xdd171223, 0x8b61, 0x4769, 0x90, 0xe3, 0x16, 0x0c, 0xcd, 0xe4, 0xe2, 0xc1);
+WINADAPTER_IID(ID3D12GraphicsCommandList8, 0xee936ef9, 0x599d, 0x4d28, 0x93, 0x8e, 0x23, 0xc4, 0xad, 0x05, 0xce, 0x51);
+#endif
+
+// Direct3D Video
+#ifdef __d3d12video_h__
+WINADAPTER_IID(ID3D12VideoDecoderHeap,0x0946B7C9,0xEBF6,0x4047,0xBB,0x73,0x86,0x83,0xE2,0x7D,0xBB,0x1F);
+WINADAPTER_IID(ID3D12VideoDevice,0x1F052807,0x0B46,0x4ACC,0x8A,0x89,0x36,0x4F,0x79,0x37,0x18,0xA4);
+WINADAPTER_IID(ID3D12VideoDecoder,0xC59B6BDC,0x7720,0x4074,0xA1,0x36,0x17,0xA1,0x56,0x03,0x74,0x70);
+WINADAPTER_IID(ID3D12VideoProcessor,0x304FDB32,0xBEDE,0x410A,0x85,0x45,0x94,0x3A,0xC6,0xA4,0x61,0x38);
+WINADAPTER_IID(ID3D12VideoDecodeCommandList,0x3B60536E,0xAD29,0x4E64,0xA2,0x69,0xF8,0x53,0x83,0x7E,0x5E,0x53);
+WINADAPTER_IID(ID3D12VideoProcessCommandList,0xAEB2543A,0x167F,0x4682,0xAC,0xC8,0xD1,0x59,0xED,0x4A,0x62,0x09);
+WINADAPTER_IID(ID3D12VideoDecodeCommandList1,0xD52F011B,0xB56E,0x453C,0xA0,0x5A,0xA7,0xF3,0x11,0xC8,0xF4,0x72);
+WINADAPTER_IID(ID3D12VideoProcessCommandList1,0x542C5C4D,0x7596,0x434F,0x8C,0x93,0x4E,0xFA,0x67,0x66,0xF2,0x67);
+WINADAPTER_IID(ID3D12VideoMotionEstimator,0x33FDAE0E,0x098B,0x428F,0x87,0xBB,0x34,0xB6,0x95,0xDE,0x08,0xF8);
+WINADAPTER_IID(ID3D12VideoMotionVectorHeap,0x5BE17987,0x743A,0x4061,0x83,0x4B,0x23,0xD2,0x2D,0xAE,0xA5,0x05);
+WINADAPTER_IID(ID3D12VideoDevice1,0x981611AD,0xA144,0x4C83,0x98,0x90,0xF3,0x0E,0x26,0xD6,0x58,0xAB);
+WINADAPTER_IID(ID3D12VideoEncodeCommandList,0x8455293A,0x0CBD,0x4831,0x9B,0x39,0xFB,0xDB,0xAB,0x72,0x47,0x23);
+WINADAPTER_IID(ID3D12VideoDecoder1,0x79A2E5FB,0xCCD2,0x469A,0x9F,0xDE,0x19,0x5D,0x10,0x95,0x1F,0x7E);
+WINADAPTER_IID(ID3D12VideoDecoderHeap1,0xDA1D98C5,0x539F,0x41B2,0xBF,0x6B,0x11,0x98,0xA0,0x3B,0x6D,0x26);
+WINADAPTER_IID(ID3D12VideoProcessor1,0xF3CFE615,0x553F,0x425C,0x86,0xD8,0xEE,0x8C,0x1B,0x1F,0xB0,0x1C);
+WINADAPTER_IID(ID3D12VideoExtensionCommand,0x554E41E8,0xAE8E,0x4A8C,0xB7,0xD2,0x5B,0x4F,0x27,0x4A,0x30,0xE4);
+WINADAPTER_IID(ID3D12VideoDevice2,0xF019AC49,0xF838,0x4A95,0x9B,0x17,0x57,0x94,0x37,0xC8,0xF5,0x13);
+WINADAPTER_IID(ID3D12VideoDecodeCommandList2,0x6e120880,0xc114,0x4153,0x80,0x36,0xd2,0x47,0x05,0x1e,0x17,0x29);
+WINADAPTER_IID(ID3D12VideoDecodeCommandList3,0x2aee8c37,0x9562,0x42da,0x8a,0xbf,0x61,0xef,0xeb,0x2e,0x45,0x13);
+WINADAPTER_IID(ID3D12VideoProcessCommandList2,0xdb525ae4,0x6ad6,0x473c,0xba,0xa7,0x59,0xb2,0xe3,0x70,0x82,0xe4);
+WINADAPTER_IID(ID3D12VideoProcessCommandList3,0x1a0a4ca4,0x9f08,0x40ce,0x95,0x58,0xb4,0x11,0xfd,0x26,0x66,0xff);
+WINADAPTER_IID(ID3D12VideoEncodeCommandList1,0x94971eca,0x2bdb,0x4769,0x88,0xcf,0x36,0x75,0xea,0x75,0x7e,0xbc);
+WINADAPTER_IID(ID3D12VideoEncoder,0x2E0D212D,0x8DF9,0x44A6,0xA7,0x70,0xBB,0x28,0x9B,0x18,0x27,0x37);
+WINADAPTER_IID(ID3D12VideoEncoderHeap,0x22B35D96,0x876A,0x44C0,0xB2,0x5E,0xFB,0x8C,0x9C,0x7F,0x1C,0x4A);
+WINADAPTER_IID(ID3D12VideoDevice3,0x4243ADB4,0x3A32,0x4666,0x97,0x3C,0x0C,0xCC,0x56,0x25,0xDC,0x44);
+WINADAPTER_IID(ID3D12VideoEncodeCommandList2,0x895491e2,0xe701,0x46a9,0x9a,0x1f,0x8d,0x34,0x80,0xed,0x86,0x7a);
+WINADAPTER_IID(ID3D12VideoEncodeCommandList3,0x7f027b22,0x1515,0x4e85,0xaa,0x0d,0x02,0x64,0x86,0x58,0x05,0x76);
+#endif
+
+#ifdef __d3d12sdklayers_h__
+WINADAPTER_IID(ID3D12Debug, 0x344488b7, 0x6846, 0x474b, 0xb9, 0x89, 0xf0, 0x27, 0x44, 0x82, 0x45, 0xe0);
+WINADAPTER_IID(ID3D12Debug1, 0xaffaa4ca, 0x63fe, 0x4d8e, 0xb8, 0xad, 0x15, 0x90, 0x00, 0xaf, 0x43, 0x04);
+WINADAPTER_IID(ID3D12Debug2, 0x93a665c4, 0xa3b2, 0x4e5d, 0xb6, 0x92, 0xa2, 0x6a, 0xe1, 0x4e, 0x33, 0x74);
+WINADAPTER_IID(ID3D12Debug3, 0x5cf4e58f, 0xf671, 0x4ff1, 0xa5, 0x42, 0x36, 0x86, 0xe3, 0xd1, 0x53, 0xd1);
+WINADAPTER_IID(ID3D12Debug4, 0x014b816e, 0x9ec5, 0x4a2f, 0xa8, 0x45, 0xff, 0xbe, 0x44, 0x1c, 0xe1, 0x3a);
+WINADAPTER_IID(ID3D12Debug5, 0x548d6b12, 0x09fa, 0x40e0, 0x90, 0x69, 0x5d, 0xcd, 0x58, 0x9a, 0x52, 0xc9);
+WINADAPTER_IID(ID3D12Debug6, 0x82a816d6, 0x5d01, 0x4157, 0x97, 0xd0, 0x49, 0x75, 0x46, 0x3f, 0xd1, 0xed);
+WINADAPTER_IID(ID3D12DebugDevice1, 0xa9b71770, 0xd099, 0x4a65, 0xa6, 0x98, 0x3d, 0xee, 0x10, 0x02, 0x0f, 0x88);
+WINADAPTER_IID(ID3D12DebugDevice, 0x3febd6dd, 0x4973, 0x4787, 0x81, 0x94, 0xe4, 0x5f, 0x9e, 0x28, 0x92, 0x3e);
+WINADAPTER_IID(ID3D12DebugDevice2, 0x60eccbc1, 0x378d, 0x4df1, 0x89, 0x4c, 0xf8, 0xac, 0x5c, 0xe4, 0xd7, 0xdd);
+WINADAPTER_IID(ID3D12DebugCommandQueue, 0x09e0bf36, 0x54ac, 0x484f, 0x88, 0x47, 0x4b, 0xae, 0xea, 0xb6, 0x05, 0x3a);
+WINADAPTER_IID(ID3D12DebugCommandQueue1, 0x16be35a2, 0xbfd6, 0x49f2, 0xbc, 0xae, 0xea, 0xae, 0x4a, 0xff, 0x86, 0x2d);
+WINADAPTER_IID(ID3D12DebugCommandList1, 0x102ca951, 0x311b, 0x4b01, 0xb1, 0x1f, 0xec, 0xb8, 0x3e, 0x06, 0x1b, 0x37);
+WINADAPTER_IID(ID3D12DebugCommandList, 0x09e0bf36, 0x54ac, 0x484f, 0x88, 0x47, 0x4b, 0xae, 0xea, 0xb6, 0x05, 0x3f);
+WINADAPTER_IID(ID3D12DebugCommandList2, 0xaeb575cf, 0x4e06, 0x48be, 0xba, 0x3b, 0xc4, 0x50, 0xfc, 0x96, 0x65, 0x2e);
+WINADAPTER_IID(ID3D12DebugCommandList3, 0x197d5e15, 0x4d37, 0x4d34, 0xaf, 0x78, 0x72, 0x4c, 0xd7, 0x0f, 0xdb, 0x1f);
+WINADAPTER_IID(ID3D12SharingContract, 0x0adf7d52, 0x929c, 0x4e61, 0xad, 0xdb, 0xff, 0xed, 0x30, 0xde, 0x66, 0xef);
+WINADAPTER_IID(ID3D12InfoQueue, 0x0742a90b, 0xc387, 0x483f, 0xb9, 0x46, 0x30, 0xa7, 0xe4, 0xe6, 0x14, 0x58);
+WINADAPTER_IID(ID3D12InfoQueue1, 0x2852dd88, 0xb484, 0x4c0c, 0xb6, 0xb1, 0x67, 0x16, 0x85, 0x00, 0xe6, 0x00);
+#endif
+
+// DXCore
+#ifdef __dxcore_interface_h__
+WINADAPTER_IID(IDXCoreAdapterFactory, 0x78ee5945, 0xc36e, 0x4b13, 0xa6, 0x69, 0x00, 0x5d, 0xd1, 0x1c, 0x0f, 0x06);
+WINADAPTER_IID(IDXCoreAdapterList, 0x526c7776, 0x40e9, 0x459b, 0xb7, 0x11, 0xf3, 0x2a, 0xd7, 0x6d, 0xfc, 0x28);
+WINADAPTER_IID(IDXCoreAdapter, 0xf0db4c7f, 0xfe5a, 0x42a2, 0xbd, 0x62, 0xf2, 0xa6, 0xcf, 0x6f, 0xc8, 0x3e);
+#endif

EscapeTheBackroomsGUiTest/vcpkg_Out/include/gif_lib.h

@@ -0,0 +1,305 @@
+/******************************************************************************
+ 
+gif_lib.h - service library for decoding and encoding GIF images
+                                                                             
+SPDX-License-Identifier: MIT
+
+*****************************************************************************/
+
+#ifndef _GIF_LIB_H_
+#define _GIF_LIB_H_ 1
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+#define GIFLIB_MAJOR 5
+#define GIFLIB_MINOR 2
+#define GIFLIB_RELEASE 1
+
+#define GIF_ERROR   0
+#define GIF_OK      1
+
+#include <stddef.h>
+#include <stdbool.h>
+
+#define GIF_STAMP "GIFVER"          /* First chars in file - GIF stamp.  */
+#define GIF_STAMP_LEN sizeof(GIF_STAMP) - 1
+#define GIF_VERSION_POS 3           /* Version first character in stamp. */
+#define GIF87_STAMP "GIF87a"        /* First chars in file - GIF stamp.  */
+#define GIF89_STAMP "GIF89a"        /* First chars in file - GIF stamp.  */
+
+typedef unsigned char GifPixelType;
+typedef unsigned char *GifRowType;
+typedef unsigned char GifByteType;
+typedef unsigned int GifPrefixType;
+typedef int GifWord;
+
+typedef struct GifColorType {
+    GifByteType Red, Green, Blue;
+} GifColorType;
+
+typedef struct ColorMapObject {
+    int ColorCount;
+    int BitsPerPixel;
+    bool SortFlag;
+    GifColorType *Colors;    /* on malloc(3) heap */
+} ColorMapObject;
+
+typedef struct GifImageDesc {
+    GifWord Left, Top, Width, Height;   /* Current image dimensions. */
+    bool Interlace;                     /* Sequential/Interlaced lines. */
+    ColorMapObject *ColorMap;           /* The local color map */
+} GifImageDesc;
+
+typedef struct ExtensionBlock {
+    int ByteCount;
+    GifByteType *Bytes; /* on malloc(3) heap */
+    int Function;       /* The block function code */
+#define CONTINUE_EXT_FUNC_CODE    0x00    /* continuation subblock */
+#define COMMENT_EXT_FUNC_CODE     0xfe    /* comment */
+#define GRAPHICS_EXT_FUNC_CODE    0xf9    /* graphics control (GIF89) */
+#define PLAINTEXT_EXT_FUNC_CODE   0x01    /* plaintext */
+#define APPLICATION_EXT_FUNC_CODE 0xff    /* application block (GIF89) */
+} ExtensionBlock;
+
+typedef struct SavedImage {
+    GifImageDesc ImageDesc;
+    GifByteType *RasterBits;         /* on malloc(3) heap */
+    int ExtensionBlockCount;         /* Count of extensions before image */    
+    ExtensionBlock *ExtensionBlocks; /* Extensions before image */    
+} SavedImage;
+
+typedef struct GifFileType {
+    GifWord SWidth, SHeight;         /* Size of virtual canvas */
+    GifWord SColorResolution;        /* How many colors can we generate? */
+    GifWord SBackGroundColor;        /* Background color for virtual canvas */
+    GifByteType AspectByte;	     /* Used to compute pixel aspect ratio */
+    ColorMapObject *SColorMap;       /* Global colormap, NULL if nonexistent. */
+    int ImageCount;                  /* Number of current image (both APIs) */
+    GifImageDesc Image;              /* Current image (low-level API) */
+    SavedImage *SavedImages;         /* Image sequence (high-level API) */
+    int ExtensionBlockCount;         /* Count extensions past last image */
+    ExtensionBlock *ExtensionBlocks; /* Extensions past last image */    
+    int Error;			     /* Last error condition reported */
+    void *UserData;                  /* hook to attach user data (TVT) */
+    void *Private;                   /* Don't mess with this! */
+} GifFileType;
+
+#define GIF_ASPECT_RATIO(n)	((n)+15.0/64.0)
+
+typedef enum {
+    UNDEFINED_RECORD_TYPE,
+    SCREEN_DESC_RECORD_TYPE,
+    IMAGE_DESC_RECORD_TYPE, /* Begin with ',' */
+    EXTENSION_RECORD_TYPE,  /* Begin with '!' */
+    TERMINATE_RECORD_TYPE   /* Begin with ';' */
+} GifRecordType;
+
+/* func type to read gif data from arbitrary sources (TVT) */
+typedef int (*InputFunc) (GifFileType *, GifByteType *, int);
+
+/* func type to write gif data to arbitrary targets.
+ * Returns count of bytes written. (MRB)
+ */
+typedef int (*OutputFunc) (GifFileType *, const GifByteType *, int);
+
+/******************************************************************************
+ GIF89 structures
+******************************************************************************/
+
+typedef struct GraphicsControlBlock {
+    int DisposalMode;
+#define DISPOSAL_UNSPECIFIED      0       /* No disposal specified. */
+#define DISPOSE_DO_NOT            1       /* Leave image in place */
+#define DISPOSE_BACKGROUND        2       /* Set area too background color */
+#define DISPOSE_PREVIOUS          3       /* Restore to previous content */
+    bool UserInputFlag;      /* User confirmation required before disposal */
+    int DelayTime;           /* pre-display delay in 0.01sec units */
+    int TransparentColor;    /* Palette index for transparency, -1 if none */
+#define NO_TRANSPARENT_COLOR	-1
+} GraphicsControlBlock;
+
+/******************************************************************************
+ GIF encoding routines
+******************************************************************************/
+
+/* Main entry points */
+GifFileType *EGifOpenFileName(const char *GifFileName,
+                              const bool GifTestExistence, int *Error);
+GifFileType *EGifOpenFileHandle(const int GifFileHandle, int *Error);
+GifFileType *EGifOpen(void *userPtr, OutputFunc writeFunc, int *Error);
+int EGifSpew(GifFileType * GifFile);
+const char *EGifGetGifVersion(GifFileType *GifFile); /* new in 5.x */
+int EGifCloseFile(GifFileType *GifFile, int *ErrorCode);
+
+#define E_GIF_SUCCEEDED          0
+#define E_GIF_ERR_OPEN_FAILED    1    /* And EGif possible errors. */
+#define E_GIF_ERR_WRITE_FAILED   2
+#define E_GIF_ERR_HAS_SCRN_DSCR  3
+#define E_GIF_ERR_HAS_IMAG_DSCR  4
+#define E_GIF_ERR_NO_COLOR_MAP   5
+#define E_GIF_ERR_DATA_TOO_BIG   6
+#define E_GIF_ERR_NOT_ENOUGH_MEM 7
+#define E_GIF_ERR_DISK_IS_FULL   8
+#define E_GIF_ERR_CLOSE_FAILED   9
+#define E_GIF_ERR_NOT_WRITEABLE  10
+
+/* These are legacy.  You probably do not want to call them directly */
+int EGifPutScreenDesc(GifFileType *GifFile,
+                      const int GifWidth, const int GifHeight, 
+		      const int GifColorRes,
+                      const int GifBackGround,
+                      const ColorMapObject *GifColorMap);
+int EGifPutImageDesc(GifFileType *GifFile, 
+		     const int GifLeft, const int GifTop,
+                     const int GifWidth, const int GifHeight, 
+		     const bool GifInterlace,
+                     const ColorMapObject *GifColorMap);
+void EGifSetGifVersion(GifFileType *GifFile, const bool gif89);
+int EGifPutLine(GifFileType *GifFile, GifPixelType *GifLine,
+                int GifLineLen);
+int EGifPutPixel(GifFileType *GifFile, const GifPixelType GifPixel);
+int EGifPutComment(GifFileType *GifFile, const char *GifComment);
+int EGifPutExtensionLeader(GifFileType *GifFile, const int GifExtCode);
+int EGifPutExtensionBlock(GifFileType *GifFile,
+                         const int GifExtLen, const void *GifExtension);
+int EGifPutExtensionTrailer(GifFileType *GifFile);
+int EGifPutExtension(GifFileType *GifFile, const int GifExtCode, 
+		     const int GifExtLen,
+                     const void *GifExtension);
+int EGifPutCode(GifFileType *GifFile, int GifCodeSize,
+                const GifByteType *GifCodeBlock);
+int EGifPutCodeNext(GifFileType *GifFile,
+                    const GifByteType *GifCodeBlock);
+
+/******************************************************************************
+ GIF decoding routines
+******************************************************************************/
+
+/* Main entry points */
+GifFileType *DGifOpenFileName(const char *GifFileName, int *Error);
+GifFileType *DGifOpenFileHandle(int GifFileHandle, int *Error);
+int DGifSlurp(GifFileType * GifFile);
+GifFileType *DGifOpen(void *userPtr, InputFunc readFunc, int *Error);    /* new one (TVT) */
+    int DGifCloseFile(GifFileType * GifFile, int *ErrorCode);
+
+#define D_GIF_SUCCEEDED          0
+#define D_GIF_ERR_OPEN_FAILED    101    /* And DGif possible errors. */
+#define D_GIF_ERR_READ_FAILED    102
+#define D_GIF_ERR_NOT_GIF_FILE   103
+#define D_GIF_ERR_NO_SCRN_DSCR   104
+#define D_GIF_ERR_NO_IMAG_DSCR   105
+#define D_GIF_ERR_NO_COLOR_MAP   106
+#define D_GIF_ERR_WRONG_RECORD   107
+#define D_GIF_ERR_DATA_TOO_BIG   108
+#define D_GIF_ERR_NOT_ENOUGH_MEM 109
+#define D_GIF_ERR_CLOSE_FAILED   110
+#define D_GIF_ERR_NOT_READABLE   111
+#define D_GIF_ERR_IMAGE_DEFECT   112
+#define D_GIF_ERR_EOF_TOO_SOON   113
+
+/* These are legacy.  You probably do not want to call them directly */
+int DGifGetScreenDesc(GifFileType *GifFile);
+int DGifGetRecordType(GifFileType *GifFile, GifRecordType *GifType);
+int DGifGetImageHeader(GifFileType *GifFile);
+int DGifGetImageDesc(GifFileType *GifFile);
+int DGifGetLine(GifFileType *GifFile, GifPixelType *GifLine, int GifLineLen);
+int DGifGetPixel(GifFileType *GifFile, GifPixelType GifPixel);
+int DGifGetExtension(GifFileType *GifFile, int *GifExtCode,
+                     GifByteType **GifExtension);
+int DGifGetExtensionNext(GifFileType *GifFile, GifByteType **GifExtension);
+int DGifGetCode(GifFileType *GifFile, int *GifCodeSize,
+                GifByteType **GifCodeBlock);
+int DGifGetCodeNext(GifFileType *GifFile, GifByteType **GifCodeBlock);
+int DGifGetLZCodes(GifFileType *GifFile, int *GifCode);
+const char *DGifGetGifVersion(GifFileType *GifFile);
+
+
+/******************************************************************************
+ Error handling and reporting.
+******************************************************************************/
+extern const char *GifErrorString(int ErrorCode);     /* new in 2012 - ESR */
+
+/*****************************************************************************
+ Everything below this point is new after version 1.2, supporting `slurp
+ mode' for doing I/O in two big belts with all the image-bashing in core.
+******************************************************************************/
+
+/******************************************************************************
+ Color map handling from gif_alloc.c
+******************************************************************************/
+
+extern ColorMapObject *GifMakeMapObject(int ColorCount,
+                                     const GifColorType *ColorMap);
+extern void GifFreeMapObject(ColorMapObject *Object);
+extern ColorMapObject *GifUnionColorMap(const ColorMapObject *ColorIn1,
+                                     const ColorMapObject *ColorIn2,
+                                     GifPixelType ColorTransIn2[]);
+extern int GifBitSize(int n);
+
+/******************************************************************************
+ Support for the in-core structures allocation (slurp mode).              
+******************************************************************************/
+
+extern void GifApplyTranslation(SavedImage *Image, GifPixelType Translation[]);
+extern int GifAddExtensionBlock(int *ExtensionBlock_Count,
+				ExtensionBlock **ExtensionBlocks, 
+				int Function, 
+				unsigned int Len, unsigned char ExtData[]);
+extern void GifFreeExtensions(int *ExtensionBlock_Count,
+			      ExtensionBlock **ExtensionBlocks);
+extern SavedImage *GifMakeSavedImage(GifFileType *GifFile,
+                                  const SavedImage *CopyFrom);
+extern void GifFreeSavedImages(GifFileType *GifFile);
+
+/******************************************************************************
+ 5.x functions for GIF89 graphics control blocks
+******************************************************************************/
+
+int DGifExtensionToGCB(const size_t GifExtensionLength,
+		       const GifByteType *GifExtension,
+		       GraphicsControlBlock *GCB);
+size_t EGifGCBToExtension(const GraphicsControlBlock *GCB,
+		       GifByteType *GifExtension);
+
+int DGifSavedExtensionToGCB(GifFileType *GifFile, 
+			    int ImageIndex, 
+			    GraphicsControlBlock *GCB);
+int EGifGCBToSavedExtension(const GraphicsControlBlock *GCB, 
+			    GifFileType *GifFile, 
+			    int ImageIndex);
+
+/******************************************************************************
+ The library's internal utility font                          
+******************************************************************************/
+
+#define GIF_FONT_WIDTH  8
+#define GIF_FONT_HEIGHT 8
+extern const unsigned char GifAsciiTable8x8[][GIF_FONT_WIDTH];
+
+extern void GifDrawText8x8(SavedImage *Image,
+                     const int x, const int y,
+                     const char *legend, const int color);
+
+extern void GifDrawBox(SavedImage *Image,
+                    const int x, const int y,
+                    const int w, const int d, const int color);
+
+extern void GifDrawRectangle(SavedImage *Image,
+                   const int x, const int y,
+                   const int w, const int d, const int color);
+
+#if !defined(_WIN32)
+extern void GifDrawBoxedText8x8(SavedImage *Image,
+                          const int x, const int y,
+                          const char *legend,
+                          const int border, const int bg, const int fg);
+#endif
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+#endif /* _GIF_LIB_H */
+
+/* end */

EscapeTheBackroomsGUiTest/vcpkg_Out/include/wsl/stubs/basetsd.h

@@ -0,0 +1,405 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+#pragma once
+
+// These #defines prevent the idl-generated headers from trying to include
+// Windows.h from the SDK rather than this one.
+#define RPC_NO_WINDOWS_H
+#define COM_NO_WINDOWS_H
+
+// Allcaps type definitions
+#include <stddef.h>
+#include <stdint.h>
+#include <string.h>
+#include <limits.h>
+
+// Note: using fixed-width here to match Windows widths
+// Specifically this is different for 'long' vs 'LONG'
+typedef uint8_t UINT8;
+typedef int8_t INT8;
+typedef uint16_t UINT16;
+typedef int16_t INT16;
+typedef uint32_t UINT32, UINT, ULONG, DWORD, BOOL, WINBOOL;
+typedef int32_t INT32, INT, LONG;
+typedef uint64_t UINT64, ULONG_PTR;
+typedef int64_t INT64, LONG_PTR;
+typedef void VOID, *HANDLE, *RPC_IF_HANDLE, *LPVOID;
+typedef const void *LPCVOID;
+typedef size_t SIZE_T;
+typedef float FLOAT;
+typedef double DOUBLE;
+typedef unsigned char BYTE;
+typedef int HWND;
+typedef int PALETTEENTRY;
+typedef int HDC;
+typedef uint16_t WORD;
+typedef void* PVOID;
+typedef char BOOLEAN;
+typedef uint64_t ULONGLONG;
+typedef uint16_t USHORT, *PUSHORT;
+typedef int64_t LONGLONG, *PLONGLONG;
+typedef int64_t LONG_PTR, *PLONG_PTR;
+typedef int64_t LONG64, *PLONG64;
+typedef uint64_t ULONG64, *PULONG64;
+typedef wchar_t WCHAR, *PWSTR;
+typedef uint8_t UCHAR, *PUCHAR;
+typedef uint64_t ULONG_PTR, *PULONG_PTR;
+typedef uint64_t UINT_PTR, *PUINT_PTR;
+typedef int64_t INT_PTR, *PINT_PTR;
+
+// Note: WCHAR is not the same between Windows and Linux, to enable
+// string manipulation APIs to work with resulting strings.
+// APIs to D3D/DXCore will work on Linux wchars, but beware with
+// interactions directly with the Windows kernel.
+typedef char CHAR, *PSTR, *LPSTR, TCHAR, *PTSTR;
+typedef const char *LPCSTR, *PCSTR, *LPCTSTR, *PCTSTR;
+typedef wchar_t WCHAR, *PWSTR, *LPWSTR, *PWCHAR;
+typedef const wchar_t *LPCWSTR, *PCWSTR;
+
+#undef LONG_MAX
+#define LONG_MAX INT_MAX
+#undef ULONG_MAX
+#define ULONG_MAX UINT_MAX
+
+// Misc defines
+#define MIDL_INTERFACE(x) interface
+#define __analysis_assume(x)
+#define TRUE 1u
+#define FALSE 0u
+#define DECLSPEC_UUID(x)
+#define DECLSPEC_NOVTABLE
+#define DECLSPEC_SELECTANY
+#ifdef __cplusplus
+#define EXTERN_C extern "C"
+#else
+#define EXTERN_C extern
+#endif
+#define APIENTRY
+#define OUT
+#define IN
+#define CONST const
+#define MAX_PATH 260
+#define GENERIC_ALL 0x10000000L
+#define C_ASSERT(expr) static_assert((expr))
+#define _countof(a) (sizeof(a) / sizeof(*(a)))
+
+typedef struct tagRECTL
+{
+    LONG left;
+    LONG top;
+    LONG right;
+    LONG bottom;
+} RECTL;
+
+typedef struct tagPOINT
+{
+    int x;
+    int y;
+} POINT;
+
+typedef struct _GUID {
+    uint32_t Data1;
+    uint16_t Data2;
+    uint16_t Data3;
+    uint8_t  Data4[ 8 ];
+} GUID;
+
+#ifdef INITGUID
+#ifdef __cplusplus
+#define DEFINE_GUID(name,l,w1,w2,b1,b2,b3,b4,b5,b6,b7,b8) EXTERN_C const GUID DECLSPEC_SELECTANY name = { l, w1, w2, { b1, b2, b3, b4, b5, b6, b7, b8 } }
+#else
+#define DEFINE_GUID(name,l,w1,w2,b1,b2,b3,b4,b5,b6,b7,b8) const GUID DECLSPEC_SELECTANY name = { l, w1, w2, { b1, b2, b3, b4, b5, b6, b7, b8 } }
+#endif
+#else
+#define DEFINE_GUID(name,l,w1,w2,b1,b2,b3,b4,b5,b6,b7,b8) EXTERN_C const GUID name
+#endif
+
+typedef GUID IID;
+typedef GUID UUID;
+typedef GUID CLSID;
+#ifdef __cplusplus
+#define REFGUID const GUID &
+#define REFIID const IID &
+#define REFCLSID const IID &
+
+__inline int InlineIsEqualGUID(REFGUID rguid1, REFGUID rguid2)
+{
+    return (
+        ((uint32_t *)&rguid1)[0] == ((uint32_t *)&rguid2)[0] &&
+        ((uint32_t *)&rguid1)[1] == ((uint32_t *)&rguid2)[1] &&
+        ((uint32_t *)&rguid1)[2] == ((uint32_t *)&rguid2)[2] &&
+        ((uint32_t *)&rguid1)[3] == ((uint32_t *)&rguid2)[3]);
+}
+
+inline bool operator==(REFGUID guidOne, REFGUID guidOther)
+{
+    return !!InlineIsEqualGUID(guidOne, guidOther);
+}
+
+inline bool operator!=(REFGUID guidOne, REFGUID guidOther)
+{
+    return !(guidOne == guidOther);
+}
+
+#else
+#define REFGUID const GUID *
+#define REFIID const IID *
+#define REFCLSID const IID *
+#endif
+
+// SAL annotations
+#define _In_
+#define _In_z_
+#define _In_opt_
+#define _In_opt_z_
+#define _In_reads_(x)
+#define _In_reads_opt_(x)
+#define _In_reads_bytes_(x)
+#define _In_reads_bytes_opt_(x)
+#define _In_range_(x, y)
+#define _In_bytecount_(x)
+#define _Out_
+#define _Out_opt_
+#define _Outptr_
+#define _Outptr_opt_result_z_
+#define _Outptr_opt_result_bytebuffer_(x)
+#define _COM_Outptr_
+#define _COM_Outptr_result_maybenull_
+#define _COM_Outptr_opt_
+#define _COM_Outptr_opt_result_maybenull_
+#define _Out_writes_(x)
+#define _Out_writes_z_(x)
+#define _Out_writes_opt_(x)
+#define _Out_writes_all_(x)
+#define _Out_writes_all_opt_(x)
+#define _Out_writes_to_opt_(x, y)
+#define _Out_writes_bytes_(x)
+#define _Out_writes_bytes_all_(x)
+#define _Out_writes_bytes_all_opt_(x)
+#define _Out_writes_bytes_opt_(x)
+#define _Inout_
+#define _Inout_opt_
+#define _Inout_updates_(x)
+#define _Inout_updates_bytes_(x)
+#define _Field_size_(x)
+#define _Field_size_opt_(x)
+#define _Field_size_bytes_(x)
+#define _Field_size_full_(x)
+#define _Field_size_full_opt_(x)
+#define _Field_size_bytes_full_(x)
+#define _Field_size_bytes_full_opt_(x)
+#define _Field_size_bytes_part_(x, y)
+#define _Field_range_(x, y)
+#define _Field_z_
+#define _Check_return_
+#define _IRQL_requires_(x)
+#define _IRQL_requires_min_(x)
+#define _IRQL_requires_max_(x)
+#define _At_(x, y)
+#define _Always_(x)
+#define _Return_type_success_(x)
+#define _Translates_Win32_to_HRESULT_(x)
+#define _Maybenull_
+#define _Outptr_result_maybenull_
+#define _Outptr_result_nullonfailure_
+#define _Analysis_assume_(x)
+#define _Success_(x)
+#define _In_count_(x)
+#define _In_opt_count_(x)
+#define _Use_decl_annotations_
+#define _Null_terminated_
+
+// Calling conventions
+#define __cdecl
+#define __stdcall
+#define STDMETHODCALLTYPE
+#define STDAPICALLTYPE
+#define STDAPI EXTERN_C HRESULT STDAPICALLTYPE
+#define WINAPI
+
+#define interface struct
+#if defined (__cplusplus) && !defined (CINTERFACE)
+#define STDMETHOD(method) virtual HRESULT STDMETHODCALLTYPE method
+#define STDMETHOD_(type, method) virtual type STDMETHODCALLTYPE method
+#define PURE = 0
+#define THIS_
+#define THIS void
+#define DECLARE_INTERFACE(iface) interface DECLSPEC_NOVTABLE iface
+#define DECLARE_INTERFACE_(iface, baseiface) interface DECLSPEC_NOVTABLE iface : public baseiface
+
+interface IUnknown;
+extern "C++"
+{
+    template<typename T> void** IID_PPV_ARGS_Helper(T** pp)
+    {
+        (void)static_cast<IUnknown*>(*pp);
+        return reinterpret_cast<void**>(pp);
+    }
+}
+#define IID_PPV_ARGS(ppType) __uuidof (**(ppType)), IID_PPV_ARGS_Helper (ppType)
+#else
+#define STDMETHOD(method) HRESULT (STDMETHODCALLTYPE *method)
+#define STDMETHOD_(type, method) type (STDMETHODCALLTYPE *method)
+#define PURE
+#define THIS_ INTERFACE *This,
+#define THIS INTERFACE *This
+#ifdef CONST_VTABLE
+#define DECLARE_INTERFACE(iface) typedef interface iface { const struct iface##Vtbl *lpVtbl; } iface; typedef const struct iface##Vtbl iface##Vtbl; const struct iface##Vtbl
+#else
+#define DECLARE_INTERFACE(iface) typedef interface iface { struct iface##Vtbl *lpVtbl; } iface; typedef struct iface##Vtbl iface##Vtbl; struct iface##Vtbl
+#endif
+#define DECLARE_INTERFACE_(iface, baseiface) DECLARE_INTERFACE (iface)
+#endif
+
+#define IFACEMETHOD(method) /*override*/ STDMETHOD (method)
+#define IFACEMETHOD_(type, method) /*override*/ STDMETHOD_(type, method)
+#ifndef BEGIN_INTERFACE
+#define BEGIN_INTERFACE
+#define END_INTERFACE
+#endif
+
+// Error codes
+typedef LONG HRESULT;
+#define SUCCEEDED(hr)  (((HRESULT)(hr)) >= 0)
+#define FAILED(hr)     (((HRESULT)(hr)) < 0)
+#define S_OK           ((HRESULT)0L)
+#define S_FALSE        ((HRESULT)1L)
+#define E_NOTIMPL      ((HRESULT)0x80004001L)
+#define E_OUTOFMEMORY  ((HRESULT)0x8007000EL)
+#define E_INVALIDARG   ((HRESULT)0x80070057L)
+#define E_NOINTERFACE  ((HRESULT)0x80004002L)
+#define E_POINTER      ((HRESULT)0x80004003L)
+#define E_HANDLE       ((HRESULT)0x80070006L)
+#define E_ABORT        ((HRESULT)0x80004004L)
+#define E_FAIL         ((HRESULT)0x80004005L)
+#define E_ACCESSDENIED ((HRESULT)0x80070005L)
+#define E_UNEXPECTED   ((HRESULT)0x8000FFFFL)
+#define DXGI_ERROR_INVALID_CALL ((HRESULT)0x887A0001L)
+#define DXGI_ERROR_NOT_FOUND ((HRESULT)0x887A0002L)
+#define DXGI_ERROR_MORE_DATA ((HRESULT)0x887A0003L)
+#define DXGI_ERROR_UNSUPPORTED ((HRESULT)0x887A0004L)
+#define DXGI_ERROR_DEVICE_REMOVED ((HRESULT)0x887A0005L)
+#define DXGI_ERROR_DEVICE_HUNG ((HRESULT)0x887A0006L)
+#define DXGI_ERROR_DEVICE_RESET ((HRESULT)0x887A0007L)
+#define DXGI_ERROR_DRIVER_INTERNAL_ERROR ((HRESULT)0x887A0020L)
+
+typedef struct _LUID
+{
+    ULONG LowPart;
+    LONG HighPart;
+} LUID;
+
+typedef struct _RECT
+{
+    int left;
+    int top;
+    int right;
+    int bottom;
+} RECT;
+
+typedef union _LARGE_INTEGER {
+  struct {
+    uint32_t LowPart;
+    uint32_t HighPart;
+  } u;
+  int64_t QuadPart;
+} LARGE_INTEGER;
+typedef LARGE_INTEGER *PLARGE_INTEGER;
+
+typedef union _ULARGE_INTEGER {
+  struct {
+    uint32_t LowPart;
+    uint32_t HighPart;
+  } u;
+  uint64_t QuadPart;
+} ULARGE_INTEGER;
+typedef ULARGE_INTEGER *PULARGE_INTEGER;
+
+#define DECLARE_HANDLE(name)                                                   \
+  struct name##__ {                                                            \
+    int unused;                                                                \
+  };                                                                           \
+  typedef struct name##__ *name
+
+typedef struct _SECURITY_ATTRIBUTES {
+    DWORD nLength;
+    LPVOID lpSecurityDescriptor;
+    WINBOOL bInheritHandle;
+} SECURITY_ATTRIBUTES;
+
+struct STATSTG;
+
+#ifdef __cplusplus
+// ENUM_FLAG_OPERATORS
+// Define operator overloads to enable bit operations on enum values that are
+// used to define flags. Use DEFINE_ENUM_FLAG_OPERATORS(YOUR_TYPE) to enable these
+// operators on YOUR_TYPE.
+extern "C++" {
+    template <size_t S>
+    struct _ENUM_FLAG_INTEGER_FOR_SIZE;
+
+    template <>
+    struct _ENUM_FLAG_INTEGER_FOR_SIZE<1>
+    {
+        typedef int8_t type;
+    };
+
+    template <>
+    struct _ENUM_FLAG_INTEGER_FOR_SIZE<2>
+    {
+        typedef int16_t type;
+    };
+
+    template <>
+    struct _ENUM_FLAG_INTEGER_FOR_SIZE<4>
+    {
+        typedef int32_t type;
+    };
+
+    template <>
+    struct _ENUM_FLAG_INTEGER_FOR_SIZE<8>
+    {
+        typedef int64_t type;
+    };
+
+    // used as an approximation of std::underlying_type<T>
+    template <class T>
+    struct _ENUM_FLAG_SIZED_INTEGER
+    {
+        typedef typename _ENUM_FLAG_INTEGER_FOR_SIZE<sizeof(T)>::type type;
+    };
+
+}
+#define DEFINE_ENUM_FLAG_OPERATORS(ENUMTYPE) \
+extern "C++" { \
+inline constexpr ENUMTYPE operator | (ENUMTYPE a, ENUMTYPE b) { return ENUMTYPE(((_ENUM_FLAG_SIZED_INTEGER<ENUMTYPE>::type)a) | ((_ENUM_FLAG_SIZED_INTEGER<ENUMTYPE>::type)b)); } \
+inline ENUMTYPE &operator |= (ENUMTYPE &a, ENUMTYPE b) { return (ENUMTYPE &)(((_ENUM_FLAG_SIZED_INTEGER<ENUMTYPE>::type &)a) |= ((_ENUM_FLAG_SIZED_INTEGER<ENUMTYPE>::type)b)); } \
+inline constexpr ENUMTYPE operator & (ENUMTYPE a, ENUMTYPE b) { return ENUMTYPE(((_ENUM_FLAG_SIZED_INTEGER<ENUMTYPE>::type)a) & ((_ENUM_FLAG_SIZED_INTEGER<ENUMTYPE>::type)b)); } \
+inline ENUMTYPE &operator &= (ENUMTYPE &a, ENUMTYPE b) { return (ENUMTYPE &)(((_ENUM_FLAG_SIZED_INTEGER<ENUMTYPE>::type &)a) &= ((_ENUM_FLAG_SIZED_INTEGER<ENUMTYPE>::type)b)); } \
+inline constexpr ENUMTYPE operator ~ (ENUMTYPE a) { return ENUMTYPE(~((_ENUM_FLAG_SIZED_INTEGER<ENUMTYPE>::type)a)); } \
+inline constexpr ENUMTYPE operator ^ (ENUMTYPE a, ENUMTYPE b) { return ENUMTYPE(((_ENUM_FLAG_SIZED_INTEGER<ENUMTYPE>::type)a) ^ ((_ENUM_FLAG_SIZED_INTEGER<ENUMTYPE>::type)b)); } \
+inline ENUMTYPE &operator ^= (ENUMTYPE &a, ENUMTYPE b) { return (ENUMTYPE &)(((_ENUM_FLAG_SIZED_INTEGER<ENUMTYPE>::type &)a) ^= ((_ENUM_FLAG_SIZED_INTEGER<ENUMTYPE>::type)b)); } \
+}
+#else
+#define DEFINE_ENUM_FLAG_OPERATORS(ENUMTYPE) /* */
+#endif
+
+// D3DX12 uses these
+#include <stdlib.h>
+#define HeapAlloc(heap, flags, size) malloc(size)
+#define HeapFree(heap, flags, ptr) free(ptr)
+
+#if defined(lint)
+// Note: lint -e530 says don't complain about uninitialized variables for
+// this variable.  Error 527 has to do with unreachable code.
+// -restore restores checking to the -save state
+#define UNREFERENCED_PARAMETER(P) \
+    /*lint -save -e527 -e530 */ \
+    { \
+        (P) = (P); \
+    } \
+    /*lint -restore */
+#else
+#define UNREFERENCED_PARAMETER(P) (P)
+#endif

EscapeTheBackroomsGUiTest/vcpkg_Out/include/wsl/stubs/oaidl.h

@@ -0,0 +1,5 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+// Stub header to satisfy d3d12.h include
+#pragma once

EscapeTheBackroomsGUiTest/vcpkg_Out/include/wsl/stubs/ocidl.h

@@ -0,0 +1,5 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+// Stub header to satisfy d3d12.h include
+#pragma once

EscapeTheBackroomsGUiTest/vcpkg_Out/include/wsl/stubs/rpc.h

@@ -0,0 +1,5 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+// Stub header to satisfy d3d12.h include
+#pragma once

EscapeTheBackroomsGUiTest/vcpkg_Out/include/wsl/stubs/rpcndr.h

@@ -0,0 +1,78 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+// Stub header to satisfy d3d12.h include
+#pragma once
+
+#include "basetsd.h"
+
+#define __RPCNDR_H_VERSION__
+
+#ifdef CONST_VTABLE
+#define CONST_VTBL const
+#else
+#define CONST_VTBL
+#endif
+
+/* Macros for __uuidof template-based emulation */
+#if defined(__cplusplus)
+#if __cpp_constexpr >= 200704l && __cpp_inline_variables >= 201606L
+#define __wsl_stub_uuidof_use_constexpr 1
+#else
+#define __wsl_stub_uuidof_use_constexpr 0
+#endif
+#ifndef __GNUC__
+#error "Only support for compilers that support for `GNU C++ extension`"
+#endif
+extern "C++"                                                         {
+#if __wsl_stub_uuidof_use_constexpr
+    __extension__ template<typename T> struct __wsl_stub_uuidof_s;
+    __extension__ template<typename T> constexpr const GUID &__wsl_stub_uuidof();
+#else
+    __extension__ template<typename T> const GUID &__wsl_stub_uuidof();
+#endif
+}
+
+#if __wsl_stub_uuidof_use_constexpr
+#define __CRT_UUID_DECL(type, l, w1, w2, b1, b2, b3, b4, b5, b6, b7, b8) \
+    extern "C++"                                                         \
+    {                                                                    \
+        template <>                                                      \
+        struct __wsl_stub_uuidof_s<type>                                 \
+        {                                                                \
+            static constexpr IID __uuid_inst = {                         \
+                l, w1, w2, {b1, b2, b3, b4, b5, b6, b7, b8}};            \
+        };                                                               \
+        template <>                                                      \
+        constexpr const GUID &__wsl_stub_uuidof<type>()                  \
+        {                                                                \
+            return __wsl_stub_uuidof_s<type>::__uuid_inst;               \
+        }                                                                \
+        template <>                                                      \
+        constexpr const GUID &__wsl_stub_uuidof<type *>()                \
+        {                                                                \
+            return __wsl_stub_uuidof_s<type>::__uuid_inst;               \
+        }                                                                \
+    }
+#else
+#define __CRT_UUID_DECL(type, l, w1, w2, b1, b2, b3, b4, b5, b6, b7, b8) \
+    extern "C++"                                                         \
+    {                                                                    \
+        template <>                                                      \
+        inline const GUID &__wsl_stub_uuidof<type>()                     \
+        {                                                                \
+            static const IID __uuid_inst = {                             \
+                l, w1, w2, {b1, b2, b3, b4, b5, b6, b7, b8}};            \
+            return __uuid_inst;                                          \
+        }                                                                \
+        template <>                                                      \
+        inline const GUID &__wsl_stub_uuidof<type *>()                   \
+        {                                                                \
+            return __wsl_stub_uuidof<type>();                            \
+        }                                                                \
+    }
+#endif
+#define __uuidof(type) __wsl_stub_uuidof<__typeof(type)>()
+#else
+#define __CRT_UUID_DECL(type, l, w1, w2, b1, b2, b3, b4, b5, b6, b7, b8)
+#endif