Merge branch 'main' into update-checker

UnleashedRecomp/gpu/video.cpp

@@ -95,6 +95,14 @@ namespace plume
 #else
     extern std::unique_ptr<RenderInterface> CreateVulkanInterface();
 #endif
+
+    static std::unique_ptr<RenderInterface> CreateVulkanInterfaceWrapper() {
+#ifdef SDL_VULKAN_ENABLED
+        return CreateVulkanInterface(GameWindow::s_renderWindow);
+#else
+        return CreateVulkanInterface();
+#endif
+    }
 }
 
 #pragma pack(push, 1)
@@ -1472,7 +1480,7 @@ static void BeginCommandList()
     commandList->setGraphicsDescriptorSet(g_samplerDescriptorSet.get(), 3);
 }
 
-void Video::CreateHostDevice(const char *sdlVideoDriver)
+bool Video::CreateHostDevice(const char *sdlVideoDriver)
 {
     for (uint32_t i = 0; i < 16; i++)
         g_inputSlots[i].index = i;
@@ -1487,20 +1495,39 @@ void Video::CreateHostDevice(const char *sdlVideoDriver)
     g_vulkan = DetectWine() || Config::GraphicsAPI == EGraphicsAPI::Vulkan;
 #endif
 
-    LoadEmbeddedResources();
+    // Attempt to create the possible backends using a vector of function pointers. Whichever succeeds first will be the chosen API.
+    using RenderInterfaceFunction = std::unique_ptr<RenderInterface>(void);
+    std::vector<RenderInterfaceFunction *> interfaceFunctions;
 
-    if (g_vulkan)
-#ifdef SDL_VULKAN_ENABLED
-        g_interface = CreateVulkanInterface(GameWindow::s_renderWindow);
-#else
-        g_interface = CreateVulkanInterface();
-#endif
 #ifdef UNLEASHED_RECOMP_D3D12
-    else
+    interfaceFunctions.push_back(g_vulkan ? CreateVulkanInterfaceWrapper : CreateD3D12Interface);
-        g_interface = CreateD3D12Interface();
+    interfaceFunctions.push_back(g_vulkan ? CreateD3D12Interface : CreateVulkanInterfaceWrapper);
+#else
+    interfaceFunctions.push_back(CreateVulkanInterfaceWrapper);
 #endif
 
+    for (RenderInterfaceFunction *interfaceFunction : interfaceFunctions)
+    {
+        g_interface = interfaceFunction();
+        if (g_interface != nullptr)
+        {
             g_device = g_interface->createDevice();
+            if (g_device != nullptr)
+            {
+#ifdef UNLEASHED_RECOMP_D3D12
+                g_vulkan = (interfaceFunction == CreateVulkanInterfaceWrapper);
+#endif
+                break;
+            }
+        }
+    }
+
+    if (g_device == nullptr)
+    {
+        return false;
+    }
+
+    LoadEmbeddedResources();
 
     g_capabilities = g_device->getCapabilities();
 
@@ -1712,6 +1739,8 @@ void Video::CreateHostDevice(const char *sdlVideoDriver)
         blankTextureBarriers[i] = RenderTextureBarrier(g_blankTextures[i].get(), RenderTextureLayout::SHADER_READ);
 
     g_commandLists[g_frame]->barriers(RenderBarrierStage::NONE, blankTextureBarriers, std::size(blankTextureBarriers));
+
+    return true;
 }
 
 void Video::WaitForGPU()
@@ -2068,6 +2097,10 @@ static void DrawProfiler()
         ImGui::Text("Triangle Fan: %s", g_capabilities.triangleFan ? "Supported" : "Unsupported");
         ImGui::NewLine();
 
+        ImGui::Text("API: %s", g_vulkan ? "Vulkan" : "D3D12");
+        ImGui::Text("Device: %s", g_device->getDescription().name.c_str());
+        ImGui::Text("VRAM: %.2f MiB", (double)(g_device->getDescription().dedicatedVideoMemory) / (1024.0 * 1024.0));
+
         const char* sdlVideoDriver = SDL_GetCurrentVideoDriver();
         if (sdlVideoDriver != nullptr)
             ImGui::Text("SDL Video Driver: %s", sdlVideoDriver);

UnleashedRecomp/gpu/video.h

@@ -18,7 +18,7 @@ struct Video
     static inline uint32_t s_viewportWidth;
     static inline uint32_t s_viewportHeight;
 
-    static void CreateHostDevice(const char *sdlVideoDriver);
+    static bool CreateHostDevice(const char *sdlVideoDriver);
     static void WaitOnSwapChain();
     static void Present();
     static void StartPipelinePrecompilation();

UnleashedRecomp/kernel/xam.cpp

@@ -408,50 +408,59 @@ uint32_t XamInputGetState(uint32_t userIndex, uint32_t flags, XAMINPUT_STATE* st
     if (hid::IsInputAllowed())
         hid::GetState(userIndex, state);
 
-    if (GameWindow::s_isFocused)
-    {
     auto keyboardState = SDL_GetKeyboardState(NULL);
 
-        if (keyboardState[SDL_SCANCODE_UP])
+    if (GameWindow::s_isFocused && !keyboardState[SDL_SCANCODE_LALT])
+    {
+        if (keyboardState[Config::Key_LeftStickUp])
             state->Gamepad.sThumbLY = 32767;
-        if (keyboardState[SDL_SCANCODE_DOWN])
+        if (keyboardState[Config::Key_LeftStickDown])
             state->Gamepad.sThumbLY = -32768;
-        if (keyboardState[SDL_SCANCODE_LEFT])
+        if (keyboardState[Config::Key_LeftStickLeft])
             state->Gamepad.sThumbLX = -32768;
-        if (keyboardState[SDL_SCANCODE_RIGHT])
+        if (keyboardState[Config::Key_LeftStickRight])
             state->Gamepad.sThumbLX = 32767;
 
-        if (keyboardState[SDL_SCANCODE_1])
+        if (keyboardState[Config::Key_RightStickUp])
+            state->Gamepad.sThumbRY = 32767;
+        if (keyboardState[Config::Key_RightStickDown])
+            state->Gamepad.sThumbRY = -32768;
+        if (keyboardState[Config::Key_RightStickLeft])
+            state->Gamepad.sThumbRX = -32768;
+        if (keyboardState[Config::Key_RightStickRight])
+            state->Gamepad.sThumbRX = 32767;
+
+        if (keyboardState[Config::Key_LeftTrigger])
             state->Gamepad.bLeftTrigger = 0xFF;
-        if (keyboardState[SDL_SCANCODE_3])
+        if (keyboardState[Config::Key_RightTrigger])
             state->Gamepad.bRightTrigger = 0xFF;
 
-        if (keyboardState[SDL_SCANCODE_I])
+        if (keyboardState[Config::Key_DPadUp])
             state->Gamepad.wButtons |= XAMINPUT_GAMEPAD_DPAD_UP;
-        if (keyboardState[SDL_SCANCODE_K])
+        if (keyboardState[Config::Key_DPadDown])
             state->Gamepad.wButtons |= XAMINPUT_GAMEPAD_DPAD_DOWN;
-        if (keyboardState[SDL_SCANCODE_J])
+        if (keyboardState[Config::Key_DPadLeft])
             state->Gamepad.wButtons |= XAMINPUT_GAMEPAD_DPAD_LEFT;
-        if (keyboardState[SDL_SCANCODE_L])
+        if (keyboardState[Config::Key_DPadRight])
             state->Gamepad.wButtons |= XAMINPUT_GAMEPAD_DPAD_RIGHT;
 
-        if (keyboardState[SDL_SCANCODE_RETURN] && !keyboardState[SDL_SCANCODE_LALT])
+        if (keyboardState[Config::Key_Start])
             state->Gamepad.wButtons |= XAMINPUT_GAMEPAD_START;
-        if (keyboardState[SDL_SCANCODE_BACKSPACE])
+        if (keyboardState[Config::Key_Back])
             state->Gamepad.wButtons |= XAMINPUT_GAMEPAD_BACK;
 
-        if (keyboardState[SDL_SCANCODE_Q])
+        if (keyboardState[Config::Key_LeftBumper])
             state->Gamepad.wButtons |= XAMINPUT_GAMEPAD_LEFT_SHOULDER;
-        if (keyboardState[SDL_SCANCODE_E])
+        if (keyboardState[Config::Key_RightBumper])
             state->Gamepad.wButtons |= XAMINPUT_GAMEPAD_RIGHT_SHOULDER;
 
-        if (keyboardState[SDL_SCANCODE_S])
+        if (keyboardState[Config::Key_A])
             state->Gamepad.wButtons |= XAMINPUT_GAMEPAD_A;
-        if (keyboardState[SDL_SCANCODE_D])
+        if (keyboardState[Config::Key_B])
             state->Gamepad.wButtons |= XAMINPUT_GAMEPAD_B;
-        if (keyboardState[SDL_SCANCODE_A])
+        if (keyboardState[Config::Key_X])
             state->Gamepad.wButtons |= XAMINPUT_GAMEPAD_X;
-        if (keyboardState[SDL_SCANCODE_W])
+        if (keyboardState[Config::Key_Y])
             state->Gamepad.wButtons |= XAMINPUT_GAMEPAD_Y;
     }
 

UnleashedRecomp/locale/locale.cpp

@@ -383,6 +383,12 @@ std::unordered_map<std::string, std::unordered_map<ELanguage, std::string>> g_lo
             { ELanguage::English, "An update is available!\n\nWould you like to visit the\nreleases page to download it?" }
         }
     },
+    {
+        "Video_BackendError",
+        {
+            { ELanguage::English, "Unable to create a D3D12 (Windows) or Vulkan backend.\n\nPlease make sure that:\n\n- Your system meets the minimum requirements.\n- Your GPU drivers are up to date.\n- Your operating system is on the latest version available." }
+        }
+    },
     {
         "Common_On",
         {

UnleashedRecomp/main.cpp

@@ -19,6 +19,7 @@
 #include <os/logger.h>
 #include <os/process.h>
 #include <os/registry.h>
+#include <ui/game_window.h>
 #include <ui/installer_wizard.h>
 #include <mod/mod_loader.h>
 
@@ -199,7 +200,11 @@ int main(int argc, char *argv[])
     bool runInstallerWizard = forceInstaller || forceDLCInstaller || !isGameInstalled;
     if (runInstallerWizard)
     {
-        Video::CreateHostDevice(sdlVideoDriver);
+        if (!Video::CreateHostDevice(sdlVideoDriver))
+        {
+            SDL_ShowSimpleMessageBox(SDL_MESSAGEBOX_ERROR, GameWindow::GetTitle(), Localise("Video_BackendError").c_str(), GameWindow::s_pWindow);
+            return 1;
+        }
 
         if (!InstallerWizard::Run(GAME_INSTALL_DIRECTORY, isGameInstalled && forceDLCInstaller))
         {
@@ -214,7 +219,13 @@ int main(int argc, char *argv[])
     uint32_t entry = LdrLoadModule(modulePath);
 
     if (!runInstallerWizard)
-        Video::CreateHostDevice(sdlVideoDriver);
+    {
+        if (!Video::CreateHostDevice(sdlVideoDriver))
+        {
+            SDL_ShowSimpleMessageBox(SDL_MESSAGEBOX_ERROR, GameWindow::GetTitle(), Localise("Video_BackendError").c_str(), GameWindow::s_pWindow);
+            return 1;
+        }
+    }
 
     Video::StartPipelinePrecompilation();
 

UnleashedRecomp/ui/game_window.h

@@ -12,7 +12,7 @@
 class GameWindow
 {
 public:
-    static inline SDL_Window* s_pWindow;
+    static inline SDL_Window* s_pWindow = nullptr;
     static inline plume::RenderWindow s_renderWindow;
 
     static inline int s_x;

UnleashedRecomp/user/config.cpp

@@ -37,6 +37,257 @@ CONFIG_DEFINE_ENUM_TEMPLATE(EControllerIcons)
     { "PlayStation", EControllerIcons::PlayStation }
 };
 
+CONFIG_DEFINE_ENUM_TEMPLATE(SDL_Scancode)
+{
+    { "UNKNOWN", SDL_SCANCODE_UNKNOWN },
+    { "A", SDL_SCANCODE_A },
+    { "B", SDL_SCANCODE_B },
+    { "C", SDL_SCANCODE_C },
+    { "D", SDL_SCANCODE_D },
+    { "E", SDL_SCANCODE_E },
+    { "F", SDL_SCANCODE_F },
+    { "G", SDL_SCANCODE_G },
+    { "H", SDL_SCANCODE_H },
+    { "I", SDL_SCANCODE_I },
+    { "J", SDL_SCANCODE_J },
+    { "K", SDL_SCANCODE_K },
+    { "L", SDL_SCANCODE_L },
+    { "M", SDL_SCANCODE_M },
+    { "N", SDL_SCANCODE_N },
+    { "O", SDL_SCANCODE_O },
+    { "P", SDL_SCANCODE_P },
+    { "Q", SDL_SCANCODE_Q },
+    { "R", SDL_SCANCODE_R },
+    { "S", SDL_SCANCODE_S },
+    { "T", SDL_SCANCODE_T },
+    { "U", SDL_SCANCODE_U },
+    { "V", SDL_SCANCODE_V },
+    { "W", SDL_SCANCODE_W },
+    { "X", SDL_SCANCODE_X },
+    { "Y", SDL_SCANCODE_Y },
+    { "Z", SDL_SCANCODE_Z },
+    { "1", SDL_SCANCODE_1 },
+    { "2", SDL_SCANCODE_2 },
+    { "3", SDL_SCANCODE_3 },
+    { "4", SDL_SCANCODE_4 },
+    { "5", SDL_SCANCODE_5 },
+    { "6", SDL_SCANCODE_6 },
+    { "7", SDL_SCANCODE_7 },
+    { "8", SDL_SCANCODE_8 },
+    { "9", SDL_SCANCODE_9 },
+    { "0", SDL_SCANCODE_0 },
+    { "RETURN", SDL_SCANCODE_RETURN },
+    { "ESCAPE", SDL_SCANCODE_ESCAPE },
+    { "BACKSPACE", SDL_SCANCODE_BACKSPACE },
+    { "TAB", SDL_SCANCODE_TAB },
+    { "SPACE", SDL_SCANCODE_SPACE },
+    { "MINUS", SDL_SCANCODE_MINUS },
+    { "EQUALS", SDL_SCANCODE_EQUALS },
+    { "LEFTBRACKET", SDL_SCANCODE_LEFTBRACKET },
+    { "RIGHTBRACKET", SDL_SCANCODE_RIGHTBRACKET },
+    { "BACKSLASH", SDL_SCANCODE_BACKSLASH },
+    { "NONUSHASH", SDL_SCANCODE_NONUSHASH },
+    { "SEMICOLON", SDL_SCANCODE_SEMICOLON },
+    { "APOSTROPHE", SDL_SCANCODE_APOSTROPHE },
+    { "GRAVE", SDL_SCANCODE_GRAVE },
+    { "COMMA", SDL_SCANCODE_COMMA },
+    { "PERIOD", SDL_SCANCODE_PERIOD },
+    { "SLASH", SDL_SCANCODE_SLASH },
+    { "CAPSLOCK", SDL_SCANCODE_CAPSLOCK },
+    { "F1", SDL_SCANCODE_F1 },
+    { "F2", SDL_SCANCODE_F2 },
+    { "F3", SDL_SCANCODE_F3 },
+    { "F4", SDL_SCANCODE_F4 },
+    { "F5", SDL_SCANCODE_F5 },
+    { "F6", SDL_SCANCODE_F6 },
+    { "F7", SDL_SCANCODE_F7 },
+    { "F8", SDL_SCANCODE_F8 },
+    { "F9", SDL_SCANCODE_F9 },
+    { "F10", SDL_SCANCODE_F10 },
+    { "F11", SDL_SCANCODE_F11 },
+    { "F12", SDL_SCANCODE_F12 },
+    { "PRINTSCREEN", SDL_SCANCODE_PRINTSCREEN },
+    { "SCROLLLOCK", SDL_SCANCODE_SCROLLLOCK },
+    { "PAUSE", SDL_SCANCODE_PAUSE },
+    { "INSERT", SDL_SCANCODE_INSERT },
+    { "HOME", SDL_SCANCODE_HOME },
+    { "PAGEUP", SDL_SCANCODE_PAGEUP },
+    { "DELETE", SDL_SCANCODE_DELETE },
+    { "END", SDL_SCANCODE_END },
+    { "PAGEDOWN", SDL_SCANCODE_PAGEDOWN },
+    { "RIGHT", SDL_SCANCODE_RIGHT },
+    { "LEFT", SDL_SCANCODE_LEFT },
+    { "DOWN", SDL_SCANCODE_DOWN },
+    { "UP", SDL_SCANCODE_UP },
+    { "NUMLOCKCLEAR", SDL_SCANCODE_NUMLOCKCLEAR },
+    { "KP_DIVIDE", SDL_SCANCODE_KP_DIVIDE },
+    { "KP_MULTIPLY", SDL_SCANCODE_KP_MULTIPLY },
+    { "KP_MINUS", SDL_SCANCODE_KP_MINUS },
+    { "KP_PLUS", SDL_SCANCODE_KP_PLUS },
+    { "KP_ENTER", SDL_SCANCODE_KP_ENTER },
+    { "KP_1", SDL_SCANCODE_KP_1 },
+    { "KP_2", SDL_SCANCODE_KP_2 },
+    { "KP_3", SDL_SCANCODE_KP_3 },
+    { "KP_4", SDL_SCANCODE_KP_4 },
+    { "KP_5", SDL_SCANCODE_KP_5 },
+    { "KP_6", SDL_SCANCODE_KP_6 },
+    { "KP_7", SDL_SCANCODE_KP_7 },
+    { "KP_8", SDL_SCANCODE_KP_8 },
+    { "KP_9", SDL_SCANCODE_KP_9 },
+    { "KP_0", SDL_SCANCODE_KP_0 },
+    { "KP_PERIOD", SDL_SCANCODE_KP_PERIOD },
+    { "NONUSBACKSLASH", SDL_SCANCODE_NONUSBACKSLASH },
+    { "APPLICATION", SDL_SCANCODE_APPLICATION },
+    { "POWER", SDL_SCANCODE_POWER },
+    { "KP_EQUALS", SDL_SCANCODE_KP_EQUALS },
+    { "F13", SDL_SCANCODE_F13 },
+    { "F14", SDL_SCANCODE_F14 },
+    { "F15", SDL_SCANCODE_F15 },
+    { "F16", SDL_SCANCODE_F16 },
+    { "F17", SDL_SCANCODE_F17 },
+    { "F18", SDL_SCANCODE_F18 },
+    { "F19", SDL_SCANCODE_F19 },
+    { "F20", SDL_SCANCODE_F20 },
+    { "F21", SDL_SCANCODE_F21 },
+    { "F22", SDL_SCANCODE_F22 },
+    { "F23", SDL_SCANCODE_F23 },
+    { "F24", SDL_SCANCODE_F24 },
+    { "EXECUTE", SDL_SCANCODE_EXECUTE },
+    { "HELP", SDL_SCANCODE_HELP },
+    { "MENU", SDL_SCANCODE_MENU },
+    { "SELECT", SDL_SCANCODE_SELECT },
+    { "STOP", SDL_SCANCODE_STOP },
+    { "AGAIN", SDL_SCANCODE_AGAIN },
+    { "UNDO", SDL_SCANCODE_UNDO },
+    { "CUT", SDL_SCANCODE_CUT },
+    { "COPY", SDL_SCANCODE_COPY },
+    { "PASTE", SDL_SCANCODE_PASTE },
+    { "FIND", SDL_SCANCODE_FIND },
+    { "MUTE", SDL_SCANCODE_MUTE },
+    { "VOLUMEUP", SDL_SCANCODE_VOLUMEUP },
+    { "VOLUMEDOWN", SDL_SCANCODE_VOLUMEDOWN },
+    { "KP_COMMA", SDL_SCANCODE_KP_COMMA },
+    { "KP_EQUALSAS400", SDL_SCANCODE_KP_EQUALSAS400 },
+    { "INTERNATIONAL1", SDL_SCANCODE_INTERNATIONAL1 },
+    { "INTERNATIONAL2", SDL_SCANCODE_INTERNATIONAL2 },
+    { "INTERNATIONAL3", SDL_SCANCODE_INTERNATIONAL3 },
+    { "INTERNATIONAL4", SDL_SCANCODE_INTERNATIONAL4 },
+    { "INTERNATIONAL5", SDL_SCANCODE_INTERNATIONAL5 },
+    { "INTERNATIONAL6", SDL_SCANCODE_INTERNATIONAL6 },
+    { "INTERNATIONAL7", SDL_SCANCODE_INTERNATIONAL7 },
+    { "INTERNATIONAL8", SDL_SCANCODE_INTERNATIONAL8 },
+    { "INTERNATIONAL9", SDL_SCANCODE_INTERNATIONAL9 },
+    { "LANG1", SDL_SCANCODE_LANG1 },
+    { "LANG2", SDL_SCANCODE_LANG2 },
+    { "LANG3", SDL_SCANCODE_LANG3 },
+    { "LANG4", SDL_SCANCODE_LANG4 },
+    { "LANG5", SDL_SCANCODE_LANG5 },
+    { "LANG6", SDL_SCANCODE_LANG6 },
+    { "LANG7", SDL_SCANCODE_LANG7 },
+    { "LANG8", SDL_SCANCODE_LANG8 },
+    { "LANG9", SDL_SCANCODE_LANG9 },
+    { "ALTERASE", SDL_SCANCODE_ALTERASE },
+    { "SYSREQ", SDL_SCANCODE_SYSREQ },
+    { "CANCEL", SDL_SCANCODE_CANCEL },
+    { "CLEAR", SDL_SCANCODE_CLEAR },
+    { "PRIOR", SDL_SCANCODE_PRIOR },
+    { "RETURN2", SDL_SCANCODE_RETURN2 },
+    { "SEPARATOR", SDL_SCANCODE_SEPARATOR },
+    { "OUT", SDL_SCANCODE_OUT },
+    { "OPER", SDL_SCANCODE_OPER },
+    { "CLEARAGAIN", SDL_SCANCODE_CLEARAGAIN },
+    { "CRSEL", SDL_SCANCODE_CRSEL },
+    { "EXSEL", SDL_SCANCODE_EXSEL },
+    { "KP_00", SDL_SCANCODE_KP_00 },
+    { "KP_000", SDL_SCANCODE_KP_000 },
+    { "THOUSANDSSEPARATOR", SDL_SCANCODE_THOUSANDSSEPARATOR },
+    { "DECIMALSEPARATOR", SDL_SCANCODE_DECIMALSEPARATOR },
+    { "CURRENCYUNIT", SDL_SCANCODE_CURRENCYUNIT },
+    { "CURRENCYSUBUNIT", SDL_SCANCODE_CURRENCYSUBUNIT },
+    { "KP_LEFTPAREN", SDL_SCANCODE_KP_LEFTPAREN },
+    { "KP_RIGHTPAREN", SDL_SCANCODE_KP_RIGHTPAREN },
+    { "KP_LEFTBRACE", SDL_SCANCODE_KP_LEFTBRACE },
+    { "KP_RIGHTBRACE", SDL_SCANCODE_KP_RIGHTBRACE },
+    { "KP_TAB", SDL_SCANCODE_KP_TAB },
+    { "KP_BACKSPACE", SDL_SCANCODE_KP_BACKSPACE },
+    { "KP_A", SDL_SCANCODE_KP_A },
+    { "KP_B", SDL_SCANCODE_KP_B },
+    { "KP_C", SDL_SCANCODE_KP_C },
+    { "KP_D", SDL_SCANCODE_KP_D },
+    { "KP_E", SDL_SCANCODE_KP_E },
+    { "KP_F", SDL_SCANCODE_KP_F },
+    { "KP_XOR", SDL_SCANCODE_KP_XOR },
+    { "KP_POWER", SDL_SCANCODE_KP_POWER },
+    { "KP_PERCENT", SDL_SCANCODE_KP_PERCENT },
+    { "KP_LESS", SDL_SCANCODE_KP_LESS },
+    { "KP_GREATER", SDL_SCANCODE_KP_GREATER },
+    { "KP_AMPERSAND", SDL_SCANCODE_KP_AMPERSAND },
+    { "KP_DBLAMPERSAND", SDL_SCANCODE_KP_DBLAMPERSAND },
+    { "KP_VERTICALBAR", SDL_SCANCODE_KP_VERTICALBAR },
+    { "KP_DBLVERTICALBAR", SDL_SCANCODE_KP_DBLVERTICALBAR },
+    { "KP_COLON", SDL_SCANCODE_KP_COLON },
+    { "KP_HASH", SDL_SCANCODE_KP_HASH },
+    { "KP_SPACE", SDL_SCANCODE_KP_SPACE },
+    { "KP_AT", SDL_SCANCODE_KP_AT },
+    { "KP_EXCLAM", SDL_SCANCODE_KP_EXCLAM },
+    { "KP_MEMSTORE", SDL_SCANCODE_KP_MEMSTORE },
+    { "KP_MEMRECALL", SDL_SCANCODE_KP_MEMRECALL },
+    { "KP_MEMCLEAR", SDL_SCANCODE_KP_MEMCLEAR },
+    { "KP_MEMADD", SDL_SCANCODE_KP_MEMADD },
+    { "KP_MEMSUBTRACT", SDL_SCANCODE_KP_MEMSUBTRACT },
+    { "KP_MEMMULTIPLY", SDL_SCANCODE_KP_MEMMULTIPLY },
+    { "KP_MEMDIVIDE", SDL_SCANCODE_KP_MEMDIVIDE },
+    { "KP_PLUSMINUS", SDL_SCANCODE_KP_PLUSMINUS },
+    { "KP_CLEAR", SDL_SCANCODE_KP_CLEAR },
+    { "KP_CLEARENTRY", SDL_SCANCODE_KP_CLEARENTRY },
+    { "KP_BINARY", SDL_SCANCODE_KP_BINARY },
+    { "KP_OCTAL", SDL_SCANCODE_KP_OCTAL },
+    { "KP_DECIMAL", SDL_SCANCODE_KP_DECIMAL },
+    { "KP_HEXADECIMAL", SDL_SCANCODE_KP_HEXADECIMAL },
+    { "LCTRL", SDL_SCANCODE_LCTRL },
+    { "LSHIFT", SDL_SCANCODE_LSHIFT },
+    { "LALT", SDL_SCANCODE_LALT },
+    { "LGUI", SDL_SCANCODE_LGUI },
+    { "RCTRL", SDL_SCANCODE_RCTRL },
+    { "RSHIFT", SDL_SCANCODE_RSHIFT },
+    { "RALT", SDL_SCANCODE_RALT },
+    { "RGUI", SDL_SCANCODE_RGUI },
+    { "MODE", SDL_SCANCODE_MODE },
+    { "AUDIONEXT", SDL_SCANCODE_AUDIONEXT },
+    { "AUDIOPREV", SDL_SCANCODE_AUDIOPREV },
+    { "AUDIOSTOP", SDL_SCANCODE_AUDIOSTOP },
+    { "AUDIOPLAY", SDL_SCANCODE_AUDIOPLAY },
+    { "AUDIOMUTE", SDL_SCANCODE_AUDIOMUTE },
+    { "MEDIASELECT", SDL_SCANCODE_MEDIASELECT },
+    { "WWW", SDL_SCANCODE_WWW },
+    { "MAIL", SDL_SCANCODE_MAIL },
+    { "CALCULATOR", SDL_SCANCODE_CALCULATOR },
+    { "COMPUTER", SDL_SCANCODE_COMPUTER },
+    { "AC_SEARCH", SDL_SCANCODE_AC_SEARCH },
+    { "AC_HOME", SDL_SCANCODE_AC_HOME },
+    { "AC_BACK", SDL_SCANCODE_AC_BACK },
+    { "AC_FORWARD", SDL_SCANCODE_AC_FORWARD },
+    { "AC_STOP", SDL_SCANCODE_AC_STOP },
+    { "AC_REFRESH", SDL_SCANCODE_AC_REFRESH },
+    { "AC_BOOKMARKS", SDL_SCANCODE_AC_BOOKMARKS },
+    { "BRIGHTNESSDOWN", SDL_SCANCODE_BRIGHTNESSDOWN },
+    { "BRIGHTNESSUP", SDL_SCANCODE_BRIGHTNESSUP },
+    { "DISPLAYSWITCH", SDL_SCANCODE_DISPLAYSWITCH },
+    { "KBDILLUMTOGGLE", SDL_SCANCODE_KBDILLUMTOGGLE },
+    { "KBDILLUMDOWN", SDL_SCANCODE_KBDILLUMDOWN },
+    { "KBDILLUMUP", SDL_SCANCODE_KBDILLUMUP },
+    { "EJECT", SDL_SCANCODE_EJECT },
+    { "SLEEP", SDL_SCANCODE_SLEEP },
+    { "APP1", SDL_SCANCODE_APP1 },
+    { "APP2", SDL_SCANCODE_APP2 },
+    { "AUDIOREWIND", SDL_SCANCODE_AUDIOREWIND },
+    { "AUDIOFASTFORWARD", SDL_SCANCODE_AUDIOFASTFORWARD },
+    { "SOFTLEFT", SDL_SCANCODE_SOFTLEFT },
+    { "SOFTRIGHT", SDL_SCANCODE_SOFTRIGHT },
+    { "CALL", SDL_SCANCODE_CALL },
+    { "ENDCALL", SDL_SCANCODE_ENDCALL },
+};
+
 CONFIG_DEFINE_ENUM_TEMPLATE(EChannelConfiguration)
 {
     { "Stereo",   EChannelConfiguration::Stereo },

UnleashedRecomp/user/config_def.h

@@ -16,6 +16,29 @@ CONFIG_DEFINE_LOCALISED("Input", bool, Vibration, true);
 CONFIG_DEFINE_LOCALISED("Input", bool, AllowBackgroundInput, false);
 CONFIG_DEFINE_ENUM_LOCALISED("Input", EControllerIcons, ControllerIcons, EControllerIcons::Auto);
 
+CONFIG_DEFINE_ENUM("Bindings", SDL_Scancode, Key_A, SDL_SCANCODE_S);
+CONFIG_DEFINE_ENUM("Bindings", SDL_Scancode, Key_B, SDL_SCANCODE_D);
+CONFIG_DEFINE_ENUM("Bindings", SDL_Scancode, Key_X, SDL_SCANCODE_A);
+CONFIG_DEFINE_ENUM("Bindings", SDL_Scancode, Key_Y, SDL_SCANCODE_W);
+CONFIG_DEFINE_ENUM("Bindings", SDL_Scancode, Key_DPadUp, SDL_SCANCODE_UNKNOWN);
+CONFIG_DEFINE_ENUM("Bindings", SDL_Scancode, Key_DPadDown, SDL_SCANCODE_UNKNOWN);
+CONFIG_DEFINE_ENUM("Bindings", SDL_Scancode, Key_DPadLeft, SDL_SCANCODE_UNKNOWN);
+CONFIG_DEFINE_ENUM("Bindings", SDL_Scancode, Key_DPadRight, SDL_SCANCODE_UNKNOWN);
+CONFIG_DEFINE_ENUM("Bindings", SDL_Scancode, Key_Start, SDL_SCANCODE_RETURN);
+CONFIG_DEFINE_ENUM("Bindings", SDL_Scancode, Key_Back, SDL_SCANCODE_BACKSPACE);
+CONFIG_DEFINE_ENUM("Bindings", SDL_Scancode, Key_LeftTrigger, SDL_SCANCODE_1);
+CONFIG_DEFINE_ENUM("Bindings", SDL_Scancode, Key_RightTrigger, SDL_SCANCODE_3);
+CONFIG_DEFINE_ENUM("Bindings", SDL_Scancode, Key_LeftBumper, SDL_SCANCODE_Q);
+CONFIG_DEFINE_ENUM("Bindings", SDL_Scancode, Key_RightBumper, SDL_SCANCODE_E);
+CONFIG_DEFINE_ENUM("Bindings", SDL_Scancode, Key_LeftStickUp, SDL_SCANCODE_UP);
+CONFIG_DEFINE_ENUM("Bindings", SDL_Scancode, Key_LeftStickDown, SDL_SCANCODE_DOWN);
+CONFIG_DEFINE_ENUM("Bindings", SDL_Scancode, Key_LeftStickLeft, SDL_SCANCODE_LEFT);
+CONFIG_DEFINE_ENUM("Bindings", SDL_Scancode, Key_LeftStickRight, SDL_SCANCODE_RIGHT);
+CONFIG_DEFINE_ENUM("Bindings", SDL_Scancode, Key_RightStickUp, SDL_SCANCODE_UNKNOWN);
+CONFIG_DEFINE_ENUM("Bindings", SDL_Scancode, Key_RightStickDown, SDL_SCANCODE_UNKNOWN);
+CONFIG_DEFINE_ENUM("Bindings", SDL_Scancode, Key_RightStickLeft, SDL_SCANCODE_UNKNOWN);
+CONFIG_DEFINE_ENUM("Bindings", SDL_Scancode, Key_RightStickRight, SDL_SCANCODE_UNKNOWN);
+
 CONFIG_DEFINE_LOCALISED("Audio", float, MasterVolume, 1.0f);
 CONFIG_DEFINE_LOCALISED("Audio", float, MusicVolume, 1.0f);
 CONFIG_DEFINE_LOCALISED("Audio", float, EffectsVolume, 1.0f);