Merge pull request #2495 from RadWolfie/d3d8ltcg-patches

D3D8LTCG: Add missing patches according to XbSymbolDatabase's symbols found

.github/labeler.yml

@@ -1,36 +1,52 @@
 # Labels are in alphabetical order.
 
 cmake:
+- changed-files:
+  - any-glob-to-any-file:
     - 'CMake*'
     - '**/CMakeLists.txt'
     - '**/*.cmake'
 
 cpu-emulation:
+- changed-files:
+  - any-glob-to-any-file:
     - 'src/devices/x86/**'
 
 deployment:
+- changed-files:
+  - any-glob-to-any-file:
     - '*.yml'
     - '.github/workflows/CI.yml'
 
 file-system:
+- changed-files:
+  - any-glob-to-any-file:
     - 'src/core/kernel/support/EmuFile*'
 
 graphics:
+- changed-files:
+  - any-glob-to-any-file:
     - 'src/core/hle/D3D8/**'
     - 'src/core/hle/XGRAPHIC/**'
     - 'src/devices/video/**'
     - 'src/gui/*Video*'
 
 HLE:
+- changed-files:
+  - any-glob-to-any-file:
     - 'src/core/hle/**'
     - 'src/core/kernel/**'
 
 informational:
+- changed-files:
+  - any-glob-to-any-file:
     - '**/*Logging*'
     - '**/*Logging*/**'
     - '**/README.md'
 
 input:
+- changed-files:
+  - any-glob-to-any-file:
     - 'src/common/input/**'
     - 'src/core/hle/XAPI/input/**'
     - 'src/devices/usb/**'
@@ -38,20 +54,30 @@ input:
     - 'src/gui/*Input*'
 
 kernel:
+- changed-files:
+  - any-glob-to-any-file:
     - 'src/core/kernel/**'
 
 LLE:
+- changed-files:
+  - any-glob-to-any-file:
     - 'src/devices/**'
 
 memory:
+- changed-files:
+  - any-glob-to-any-file:
     - 'src/core/kernel/memory-manager/**'
 
 networking:
+- changed-files:
+  - any-glob-to-any-file:
     - 'src/core/hle/XONLINE/**'
     - 'src/devices/network/**'
     - 'src/gui/*Network*'
 
 sound:
+- changed-files:
+  - any-glob-to-any-file:
     - 'src/common/audio/**'
     - 'src/core/hle/DSOUND/**'
     - 'src/core/hle/XACTENG/**'
@@ -59,17 +85,27 @@ sound:
     - 'src/gui/*Audio*'
 
 modules:
+- changed-files:
+  - any-glob-to-any-file:
     - 'import/**'
 
 threading:
+- changed-files:
+  - any-glob-to-any-file:
     - 'src/core/kernel/support/EmuFS*'
 
 timing:
+- changed-files:
+  - any-glob-to-any-file:
     - 'src/common/Timer*'
 
 user interface:
+- changed-files:
+  - any-glob-to-any-file:
     - 'src/core/common/imgui/*'
     - 'src/gui/**'
 
 xbdm:
+- changed-files:
+  - any-glob-to-any-file:
     - 'src/common/xbdm/**'

.github/workflows/CI.yml

@@ -22,32 +22,29 @@ on:
 
 jobs:
   build-windows:
-    name: Build (Windows, ${{ matrix.configuration }}, VS${{ matrix.vsver }}) # runner.os doesn't work here
-    runs-on: windows-${{ matrix.vsver }}
+    name: Build (Windows, ${{ matrix.configuration }}) # runner.os doesn't work here
+    runs-on: windows-2025
     env:
       POWERSHELL_TELEMETRY_OPTOUT: 1
     strategy:
       fail-fast: false
       matrix:
         configuration: [Release, Debug]
-        vsver: [2019]
-        winver: [7]
-        sdkver: [10.0.22621.0]
     steps:
       - uses: actions/checkout@v4
         with:
           submodules: recursive
       - name: Generate CMake files
-        run: cmake -B build -A Win32,version=${{ matrix.sdkver }} -DCMAKE_SYSTEM_VERSION=${{ matrix.winver }}
+        run: cmake -B build -A Win32 -DBUILD_CXBXR_DEBUGGER=ON -DCMAKE_SYSTEM_VERSION=7
       - name: Build
         run: cmake --build build --config ${{ matrix.configuration }} -j $env:NUMBER_OF_PROCESSORS
       - name: Prepare artifacts
         if: matrix.configuration == 'Release'
         run: cmake --install build --config ${{ matrix.configuration }} --prefix artifacts
-      - uses: actions/upload-artifact@v3
+      - uses: actions/upload-artifact@v4
         if: matrix.configuration == 'Release'
         with:
-          name: CxbxReloaded-${{ matrix.configuration }}-VS${{ matrix.vsver }}
+          name: CxbxReloaded-${{ matrix.configuration }}
           path: artifacts/bin
           if-no-files-found: error
 
@@ -61,7 +58,7 @@ jobs:
     steps:
       - uses: actions/checkout@v4
       - name: Download artifacts
-        uses: actions/download-artifact@v3
+        uses: actions/download-artifact@v4
         with:
           path: artifacts
       - name: Re-zip artifacts

.github/workflows/autoclose.yml

@@ -7,9 +7,9 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Checkout
-        uses: actions/checkout@v3
+        uses: actions/checkout@v4
       - name: Automatically close issues that don't follow the issue template
-        uses: ergo720/auto-close-issues@v1.0.4
+        uses: ergo720/auto-close-issues@v1
         with:
           github-token: ${{ secrets.GITHUB_TOKEN }}
           issue-close-message: "@${issue.user.login}: your issue has been automatically closed because it does not follow the issue template."  # optional property

.github/workflows/pull-request.yml

@@ -7,7 +7,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Labeler
-        uses: actions/labeler@v4
+        uses: actions/labeler@v5
         with:
           repo-token: ${{ secrets.GITHUB_TOKEN }}
           sync-labels: true

CMakeLists.txt

@@ -1,4 +1,4 @@
-cmake_minimum_required (VERSION 3.8)
+cmake_minimum_required (VERSION 3.12)
 
 project(Cxbx-Reloaded)
 
@@ -430,6 +430,12 @@ file (GLOB CXBXR_SOURCE_EMU
  "${CXBXR_ROOT_DIR}/src/common/ReserveAddressRanges.cpp"
 )
 
+
+option(BUILD_CXBXR_DEBUGGER "Build cxbxr-debugger tool (with cheat table support)")
+if(BUILD_CXBXR_DEBUGGER)
+ message(DEPRECATION "The Cxbxr-Debugger tool will eventually be removed from the upstream branch.")
+endif()
+
 add_subdirectory("${CMAKE_CURRENT_LIST_DIR}/projects/cxbx")
 
 add_subdirectory("${CMAKE_CURRENT_LIST_DIR}/projects/cxbxr-ldr")
@@ -454,7 +460,7 @@ endif()
 
 # Check if generator is Visual Studio then enable Cxbxr-Debugger project.
 # Since C# is currently supported with Visual Studio for now.
-if(${CMAKE_GENERATOR} MATCHES "Visual Studio ([^9]|[9][0-9])")
+if(${CMAKE_GENERATOR} MATCHES "Visual Studio ([^9]|[9][0-9])" AND BUILD_CXBXR_DEBUGGER)
  # Issues with compile (the same with develop branch) and
  # for some reason did not put the files into virtual folder?
  # Might need to put the list in the source folder for workaround fix.

README.md

@@ -89,6 +89,7 @@ Don't open `CMakeLists.txt` from Visual Studio, as it won't generate files in th
 1. [Visual Studio](https://visualstudio.microsoft.com/downloads/) 2022
     * C++ and C# desktop development
     * Windows Universal CRT SDK
+    * Windows 11 SDK (10.0.22621.0) or later
     * C++ CMake tools for Windows
       * *Optional if CMake is installed*
     * [Microsoft Child Process Debugging Power Tool](https://marketplace.visualstudio.com/items?itemName=vsdbgplat.MicrosoftChildProcessDebuggingPowerTool)
@@ -96,10 +97,11 @@ Don't open `CMakeLists.txt` from Visual Studio, as it won't generate files in th
 ##### Generate Visual Studio files
 1. If you don't have CMake installed, open `___ Native Tools Command Prompt for VS 20##`.
 2. `cd` to the Cxbx-Reloaded directory.
-3. Run these commands.
-    1. `mkdir build & cd build`
-    2. `cmake .. -G "Visual Studio 17 2022" -A Win32`
+3. Run the following command: `cmake -B build -G "Visual Studio 17 2022" -A Win32` \
+   **NOTES**:
      * VS2022 17.0 or later is required.
+     * To build the Cxbx-Reloaded Debugger tool, add the variable `-DBUILD_CXBXR_DEBUGGER=ON` to the above command.
+       * _This debugger tool is deprecated and will be eventually removed, please use the Visual Studio debugger instead._
 4. Open `Cxbx-Reloaded.sln` from the `build` directory.
 5. Select the Release configuration, then click Build.
     * Debug builds are **significantly slower, and only for developers**.

import/SDL2

@@ -1 +1 @@
-Subproject commit b424665e0899769b200231ba943353a5fee1b6b6
+Subproject commit fa24d868ac2f8fd558e4e914c9863411245db8fd

import/XbSymbolDatabase

@@ -1 +1 @@
-Subproject commit 774111351210e6f340246d6fb32741b09708f381
+Subproject commit 6de71a326b094377f8773817e1f228a4e435496a

projects/cxbx/CMakeLists.txt

@@ -121,7 +121,7 @@ if ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "MSVC")
 
  # Reference: https://docs.microsoft.com/en-us/cpp/build/reference/compiler-options-listed-alphabetically
  # /Zi   = create a PDB file without affecting optimization
- # /Ob2  = Controls inline expansion of functions.
+ # /Ob3  = Controls inline expansion of functions.
  # /Oi   = Generate intrinsic functions
  # /Ot   = In favor of using fast code than small code
  # /GL   = Whole program optimization
@@ -132,7 +132,7 @@ if ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "MSVC")
  # Set optimization options for release build
  set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} \
   /Zi \
-  /Ob2 \
+  /Ob3 \
   /Oi \
   /Ot \
   /GL \
@@ -170,6 +170,7 @@ set(WINS_LIB
  comctl32
  XINPUT9_1_0
  Iphlpapi
+ Dwmapi
 )
 
 target_link_libraries(cxbx
@@ -188,7 +189,7 @@ install(TARGETS ${PROJECT_NAME}
   RUNTIME DESTINATION bin
 )
 
-if(${CMAKE_GENERATOR} MATCHES "Visual Studio ([^9]|[9][0-9])")
+if(${CMAKE_GENERATOR} MATCHES "Visual Studio ([^9]|[9][0-9])" AND BUILD_CXBXR_DEBUGGER)
   add_dependencies(cxbx cxbxr-debugger)
 endif()
 

projects/cxbxr-emu/CMakeLists.txt

@@ -131,7 +131,7 @@ if ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "MSVC")
  # Set optimization options for release build
  set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} \
   /Zi \
-  /Ob2 \
+  /Ob3 \
   /Oi \
   /Ot \
   /GL \

projects/imgui/CMakeLists.txt

@@ -1,4 +1,4 @@
-cmake_minimum_required (VERSION 3.8)
+cmake_minimum_required (VERSION 3.12)
 project(imgui LANGUAGES CXX)
 # Since imgui doesn't have CMake, we'll make an interface project here.
 

projects/libtom/crypt/CMakeLists.txt

@@ -1,4 +1,4 @@
-cmake_minimum_required (VERSION 3.8)
+cmake_minimum_required (VERSION 3.12)
 project(libtomcrypt)
 
 # Suppress extra stuff from generated solution

projects/libtom/math/CMakeLists.txt

@@ -1,4 +1,4 @@
-cmake_minimum_required (VERSION 3.8)
+cmake_minimum_required (VERSION 3.12)
 project(libtommath)
 
 # Suppress extra stuff from generated solution

projects/libusb/CMakeLists.txt

@@ -1,4 +1,4 @@
-cmake_minimum_required (VERSION 3.8)
+cmake_minimum_required (VERSION 3.12)
 project(libusb LANGUAGES CXX)
 # Since libusb doesn't have CMake, we'll make an interface project here.
 

src/CxbxDebugger/CMakeLists.txt

@@ -1,4 +1,4 @@
-cmake_minimum_required (VERSION 3.8)
+cmake_minimum_required (VERSION 3.12)
 project(cxbxr-debugger LANGUAGES CSharp)
 
 # Output all binary files into one folder

src/CxbxDebugger/CxbxDebuggerMain.Designer.cs

@@ -41,6 +41,7 @@
             this.windowsMenu = new System.Windows.Forms.ToolStripMenuItem();
             this.toolTip = new System.Windows.Forms.ToolTip(this.components);
             this.statusStrip1 = new System.Windows.Forms.StatusStrip();
+            this.lblStatusDeprecate = new System.Windows.Forms.ToolStripStatusLabel();
             this.lblStatus = new System.Windows.Forms.ToolStripStatusLabel();
             this.menuStrip.SuspendLayout();
             this.statusStrip1.SuspendLayout();
@@ -132,18 +133,29 @@
             // 
             this.statusStrip1.ImageScalingSize = new System.Drawing.Size(24, 24);
             this.statusStrip1.Items.AddRange(new System.Windows.Forms.ToolStripItem[] {
+            this.lblStatusDeprecate,
             this.lblStatus});
+            this.statusStrip1.LayoutStyle = System.Windows.Forms.ToolStripLayoutStyle.VerticalStackWithOverflow;
             this.statusStrip1.Location = new System.Drawing.Point(0, 339);
             this.statusStrip1.Name = "statusStrip1";
             this.statusStrip1.Padding = new System.Windows.Forms.Padding(1, 0, 9, 0);
-            this.statusStrip1.Size = new System.Drawing.Size(734, 22);
+            this.statusStrip1.Size = new System.Drawing.Size(734, 61);
             this.statusStrip1.TabIndex = 2;
             this.statusStrip1.Text = "statusStrip1";
             // 
+            // lblStatusDeprecate
+            // 
+            this.lblStatusDeprecate.BackColor = System.Drawing.Color.Yellow;
+            this.lblStatusDeprecate.Name = "lblStatusDeprecate";
+            this.lblStatusDeprecate.Size = new System.Drawing.Size(723, 15);
+            this.lblStatusDeprecate.Spring = true;
+            this.lblStatusDeprecate.Text = "WARNING: cxbxr-debugger will eventually be removed from upstream branch.";
+            this.lblStatusDeprecate.TextAlign = System.Drawing.ContentAlignment.MiddleLeft;
+            // 
             // lblStatus
             // 
             this.lblStatus.Name = "lblStatus";
-            this.lblStatus.Size = new System.Drawing.Size(39, 17);
+            this.lblStatus.Size = new System.Drawing.Size(723, 15);
             this.lblStatus.Text = "Ready";
             // 
             // CxbxDebuggerMain
@@ -180,6 +192,7 @@
         private System.Windows.Forms.ToolStripMenuItem miSuspend;
         private System.Windows.Forms.ToolStripMenuItem miResume;
         private System.Windows.Forms.StatusStrip statusStrip1;
+        private System.Windows.Forms.ToolStripStatusLabel lblStatusDeprecate;
         private System.Windows.Forms.ToolStripStatusLabel lblStatus;
     }
 }

src/common/Settings.cpp

@@ -90,6 +90,7 @@ static struct {
 	const char* DataCustomLocation = "DataCustomLocation";
 	const char* IgnoreInvalidXbeSig = "IgnoreInvalidXbeSig";
 	const char *IgnoreInvalidXbeSec = "IgnoreInvalidXbeSec";
+	const char* ConsoleTypeToggle = "ConsoleTypeToggle";
 } sect_gui_keys;
 
 static const char* section_core = "core";
@@ -342,6 +343,8 @@ bool Settings::LoadConfig()
 	m_gui.bIgnoreInvalidXbeSig = m_si.GetBoolValue(section_gui, sect_gui_keys.IgnoreInvalidXbeSig, /*Default=*/false);
 	m_gui.bIgnoreInvalidXbeSec = m_si.GetBoolValue(section_gui, sect_gui_keys.IgnoreInvalidXbeSec, /*Default=*/false);
 
+	m_gui.ConsoleTypeToggle = (EMU_CONSOLE_TYPE)m_si.GetLongValue(section_gui, sect_gui_keys.ConsoleTypeToggle, /*Default=*/EMU_CONSOLE_TYPE_AUTO);
+
 	// ==== GUI End =============
 
 	// ==== Core Begin ==========
@@ -588,6 +591,8 @@ bool Settings::Save(std::string file_path)
 	m_si.SetBoolValue(section_gui, sect_gui_keys.IgnoreInvalidXbeSig, m_gui.bIgnoreInvalidXbeSig, nullptr, true);
 	m_si.SetBoolValue(section_gui, sect_gui_keys.IgnoreInvalidXbeSec, m_gui.bIgnoreInvalidXbeSec, nullptr, true);
 
+	m_si.SetLongValue(section_gui, sect_gui_keys.ConsoleTypeToggle, m_gui.ConsoleTypeToggle, nullptr, true, true);
+
 	// ==== GUI End =============
 
 	// ==== Core Begin ==========

src/common/Settings.hpp

@@ -46,6 +46,14 @@ extern uint16_t g_LibVersion_DSOUND;
  "Invalid "#type" size, please verify structure is align, not adding new member, or is using placeholder reserves." \
  " Otherwise, please perform versioning upgrade and update "#type" sizeof check."
 
+// Toggle emulation console mode.
+typedef enum _EMU_CONSOLE_TYPE {
+	EMU_CONSOLE_TYPE_AUTO = 0,
+	EMU_CONSOLE_TYPE_RETAIL = 1,
+	EMU_CONSOLE_TYPE_DEVKIT = 2,
+	EMU_CONSOLE_TYPE_CHIHIRO = 3,
+} EMU_CONSOLE_TYPE;
+
 // Cxbx-Reloaded's data storage location.
 typedef enum _CXBX_DATA {
 	CXBX_DATA_INVALID = -1,
@@ -91,6 +99,7 @@ public:
 		std::string szCustomLocation = "";
 		bool bIgnoreInvalidXbeSig;
 		bool bIgnoreInvalidXbeSec;
+		unsigned int ConsoleTypeToggle;
 	} m_gui;
 
 	// Core settings

src/common/Timer.cpp

@@ -28,6 +28,7 @@
 #include <core\kernel\exports\xboxkrnl.h>
 
 #include <windows.h>
+#include <chrono>
 #include <thread>
 #include <vector>
 #include <mutex>

src/common/input/InputWindow.cpp

@@ -33,6 +33,7 @@
 #include "EmuShared.h"
 #include "Logging.h"
 #include <future>
+#include <chrono>
 
 
 constexpr ControlState INPUT_DETECT_THRESHOLD = 0.35; // NOTE: this should probably be made user configurable

src/common/util/cliConfig.cpp

@@ -60,6 +60,15 @@ bool hasKey(std::string key)
     return false;
 }
 
+// Delete the key if it exist
+void DeleteKey(std::string key)
+{
+    auto found = g_cli_configs.find(key);
+    if (found != g_cli_configs.end()) {
+        g_cli_configs.erase(found);
+    }
+}
+
 // Generic getter
 bool GetValue(const std::string key, std::string* value)
 {
@@ -179,4 +188,12 @@ void SetSystemType(const std::string value)
     }
 }
 
+void ClearSystemType()
+{
+    // Clear any system types key existence.
+    DeleteKey(cli_config::system_retail);
+    DeleteKey(cli_config::system_devkit);
+    DeleteKey(cli_config::system_chihiro);
+}
+
 }

src/common/util/cliConfig.hpp

@@ -57,5 +57,6 @@ long long GetSessionID();
 void SetLoad(const std::string value);
 
 void SetSystemType(const std::string value);
+void ClearSystemType();
 
 }

src/core/hle/D3D8/Direct3D9/Direct3D9.cpp.unused-patches

@@ -4280,3 +4280,50 @@ xbox::void_xt WINAPI xbox::EMUPATCH(D3DDevice_SetVerticalBlankCallback)
 
     g_pXbox_VerticalBlankCallback = pCallback;
 }
+
+// LTCG specific D3DDevice_SetFlickerFilter function...
+// This uses a custom calling convention where parameter is passed in ESI
+// Test-case: Metal Wolf Chaos
+__declspec(naked) xbox::void_xt WINAPI xbox::EMUPATCH(D3DDevice_SetFlickerFilter_0__LTCG_esi1)
+(
+)
+{
+	dword_xt Filter;
+	__asm {
+		LTCG_PROLOGUE
+		mov  Filter, esi
+	}
+
+	EMUPATCH(D3DDevice_SetFlickerFilter)(Filter);
+
+	__asm {
+		LTCG_EPILOGUE
+		ret
+	}
+}
+
+// ******************************************************************
+// * patch: D3DDevice_SetFlickerFilter
+// ******************************************************************
+void WINAPI xbox::EMUPATCH(D3DDevice_SetFlickerFilter)
+(
+    dword_xt         Filter
+)
+{
+	LOG_FUNC_ONE_ARG(Filter);
+
+	LOG_IGNORED();
+}
+
+// ******************************************************************
+// * patch: D3DDevice_SetSoftDisplayFilter
+// ******************************************************************
+void WINAPI xbox::EMUPATCH(D3DDevice_SetSoftDisplayFilter)
+(
+    bool_xt Enable
+)
+{
+	LOG_FUNC_ONE_ARG(Enable);
+
+	LOG_IGNORED();
+}

src/core/hle/D3D8/Direct3D9/Direct3D9.h

@@ -76,7 +76,7 @@ xbox::hresult_xt WINAPI EMUPATCH(Direct3D_CreateDevice)
     X_D3DDevice           **ppReturnedDeviceInterface
 );
 
-xbox::hresult_xt WINAPI EMUPATCH(Direct3D_CreateDevice_16__LTCG_eax_BehaviorFlags_ebx_ppReturnedDeviceInterface)
+xbox::hresult_xt WINAPI EMUPATCH(Direct3D_CreateDevice_16__LTCG_eax4_ebx6)
 (
     uint_xt                        Adapter,
     D3DDEVTYPE                  DeviceType,
@@ -84,7 +84,7 @@ xbox::hresult_xt WINAPI EMUPATCH(Direct3D_CreateDevice_16__LTCG_eax_BehaviorFlag
     X_D3DPRESENT_PARAMETERS    *pPresentationParameters
 );
 
-xbox::hresult_xt WINAPI EMUPATCH(Direct3D_CreateDevice_16__LTCG_eax_BehaviorFlags_ecx_ppReturnedDeviceInterface)
+xbox::hresult_xt WINAPI EMUPATCH(Direct3D_CreateDevice_16__LTCG_eax4_ecx6)
 (
     uint_xt                        Adapter,
     D3DDEVTYPE                  DeviceType,
@@ -92,7 +92,7 @@ xbox::hresult_xt WINAPI EMUPATCH(Direct3D_CreateDevice_16__LTCG_eax_BehaviorFlag
     X_D3DPRESENT_PARAMETERS    *pPresentationParameters
 );
 
-xbox::hresult_xt WINAPI EMUPATCH(Direct3D_CreateDevice_4)
+xbox::hresult_xt WINAPI EMUPATCH(Direct3D_CreateDevice_4__LTCG_eax1_ecx3)
 (
     X_D3DPRESENT_PARAMETERS    *pPresentationParameters
 );
@@ -171,7 +171,7 @@ xbox::hresult_xt WINAPI EMUPATCH(D3DDevice_EndVisibilityTest)
     dword_xt                       Index
 );
 
-xbox::hresult_xt WINAPI EMUPATCH(D3DDevice_EndVisibilityTest_0)();
+xbox::hresult_xt WINAPI EMUPATCH(D3DDevice_EndVisibilityTest_0__LTCG_eax1)();
 
 // ******************************************************************
 // * patch: D3DDevice_GetVisibilityTestResult
@@ -197,9 +197,9 @@ xbox::void_xt WINAPI EMUPATCH(D3DDevice_LoadVertexShader)
     dword_xt                       Address
 );
 
-xbox::void_xt WINAPI EMUPATCH(D3DDevice_LoadVertexShader_0__LTCG_eax_Address_ecx_Handle)();
-xbox::void_xt WINAPI EMUPATCH(D3DDevice_LoadVertexShader_0__LTCG_eax_Address_edx_Handle)();
-xbox::void_xt WINAPI EMUPATCH(D3DDevice_LoadVertexShader_4)
+xbox::void_xt WINAPI EMUPATCH(D3DDevice_LoadVertexShader_0__LTCG_ecx1_eax2)();
+xbox::void_xt WINAPI EMUPATCH(D3DDevice_LoadVertexShader_0__LTCG_edx1_eax2)();
+xbox::void_xt WINAPI EMUPATCH(D3DDevice_LoadVertexShader_4__LTCG_eax1)
 (
     dword_xt                       Address
 );
@@ -314,6 +314,15 @@ xbox::void_xt WINAPI EMUPATCH(D3DDevice_GetBackBuffer)
     X_D3DSurface     **ppBackBuffer
 );
 
+// ******************************************************************
+// * patch: D3DDevice_GetBackBuffer_8__LTCG_eax1
+// ******************************************************************
+xbox::void_xt WINAPI EMUPATCH(D3DDevice_GetBackBuffer_8__LTCG_eax1)
+(
+    D3DBACKBUFFER_TYPE Type,
+    X_D3DSurface     **ppBackBuffer
+);
+
 // ******************************************************************
 // * patch: D3DDevice_SetViewport
 // ******************************************************************
@@ -428,7 +437,7 @@ xbox::void_xt WINAPI EMUPATCH(D3DDevice_SetVertexShaderConstant)
     dword_xt       ConstantCount
 );
 
-xbox::void_xt __fastcall EMUPATCH(D3DDevice_SetVertexShaderConstant_8)
+xbox::void_xt __fastcall EMUPATCH(D3DDevice_SetVertexShaderConstant_8__LTCG_edx3)
 (
     void*,
     dword_xt    ConstantCount,
@@ -474,6 +483,11 @@ xbox::void_xt __fastcall EMUPATCH(D3DDevice_SetVertexShaderConstantNotInline)
     dword_xt       ConstantCount
 );
 
+// ******************************************************************
+// * patch: D3DDevice_SetVertexShaderConstantNotInline_0__LTCG_ebx1_edx2_eax3
+// ******************************************************************
+xbox::void_xt WINAPI EMUPATCH(D3DDevice_SetVertexShaderConstantNotInline_0__LTCG_ebx1_edx2_eax3)();
+
 // ******************************************************************
 // * patch: D3DDevice_SetVertexShaderConstantNotInlineFast
 // ******************************************************************
@@ -509,7 +523,7 @@ xbox::void_xt WINAPI EMUPATCH(D3DDevice_SetPixelShader)
     dword_xt           Handle
 );
 
-xbox::void_xt WINAPI EMUPATCH(D3DDevice_SetPixelShader_0__LTCG_eax_handle)();
+xbox::void_xt WINAPI EMUPATCH(D3DDevice_SetPixelShader_0__LTCG_eax1)();
 
 // ******************************************************************
 // * patch: D3DDevice_CreateTexture2
@@ -594,9 +608,9 @@ xbox::void_xt WINAPI EMUPATCH(D3DDevice_SetIndices)
 );
 
 // ******************************************************************
-// * patch: D3DDevice_SetIndices_4
+// * patch: D3DDevice_SetIndices_4__LTCG_ebx1
 // ******************************************************************
-xbox::void_xt WINAPI EMUPATCH(D3DDevice_SetIndices_4)
+xbox::void_xt WINAPI EMUPATCH(D3DDevice_SetIndices_4__LTCG_ebx1)
 (
     uint_xt                BaseVertexIndex
 );
@@ -610,12 +624,12 @@ xbox::void_xt WINAPI EMUPATCH(D3DDevice_SetTexture)
 	X_D3DBaseTexture  *pTexture
 );
 
-xbox::void_xt WINAPI EMUPATCH(D3DDevice_SetTexture_4__LTCG_eax_pTexture)
+xbox::void_xt WINAPI EMUPATCH(D3DDevice_SetTexture_4__LTCG_eax2)
 (
 	dword_xt           Stage
 );
 
-xbox::void_xt WINAPI EMUPATCH(D3DDevice_SetTexture_4__LTCG_eax_Stage)
+xbox::void_xt WINAPI EMUPATCH(D3DDevice_SetTexture_4__LTCG_eax1)
 (
 	X_D3DBaseTexture  *pTexture
 );
@@ -679,9 +693,9 @@ xbox::void_xt WINAPI EMUPATCH(D3DDevice_SetVertexData4f)
 );
 
 // ******************************************************************
-// * patch: D3DDevice_SetVertexData4f_16
+// * patch: D3DDevice_SetVertexData4f_16__LTCG_edi1
 // ******************************************************************
-xbox::void_xt WINAPI EMUPATCH(D3DDevice_SetVertexData4f_16)
+xbox::void_xt WINAPI EMUPATCH(D3DDevice_SetVertexData4f_16__LTCG_edi1)
 (
 	float_xt   a,
 	float_xt   b,
@@ -736,6 +750,14 @@ xbox::void_xt WINAPI EMUPATCH(D3DDevice_RunPushBuffer)
     X_D3DFixup            *pFixup
 );
 
+// ******************************************************************
+// * patch: D3DDevice_RunPushBuffer_4__LTCG_eax2
+// ******************************************************************
+xbox::void_xt WINAPI EMUPATCH(D3DDevice_RunPushBuffer_4__LTCG_eax2)
+(
+    X_D3DPushBuffer *pPushBuffer
+);
+
 // ******************************************************************
 // * patch: D3DDevice_Clear
 // ******************************************************************
@@ -768,7 +790,7 @@ dword_xt WINAPI EMUPATCH(D3DDevice_Swap)
     dword_xt Flags
 );
 
-dword_xt WINAPI EMUPATCH(D3DDevice_Swap_0)();
+dword_xt WINAPI EMUPATCH(D3DDevice_Swap_0__LTCG_eax1)();
 
 // ******************************************************************
 // * patch: IDirect3DResource8_Register
@@ -826,6 +848,17 @@ xbox::void_xt WINAPI EMUPATCH(Lock2DSurface)
     dword_xt             Flags
 );
 
+// ******************************************************************
+// * patch: Lock2DSurface_16__LTCG_esi4_eax5
+// ******************************************************************
+xbox::void_xt WINAPI EMUPATCH(Lock2DSurface_16__LTCG_esi4_eax5)
+(
+    X_D3DPixelContainer *pPixelContainer,
+    D3DCUBEMAP_FACES     FaceType,
+    uint_xt              Level,
+    dword_xt             Flags
+);
+
 // ******************************************************************
 // * patch: Lock3DSurface
 // ******************************************************************
@@ -838,6 +871,17 @@ xbox::void_xt WINAPI EMUPATCH(Lock3DSurface)
     dword_xt             Flags
 );
 
+// ******************************************************************
+// * patch: Lock3DSurface_16__LTCG_eax4
+// ******************************************************************
+xbox::void_xt WINAPI EMUPATCH(Lock3DSurface_16__LTCG_eax4)
+(
+    X_D3DPixelContainer *pPixelContainer,
+    uint_xt              Level,
+    D3DLOCKED_BOX       *pLockedVolume,
+    dword_xt             Flags
+);
+
 #if 0 // patch disabled
 // ******************************************************************
 // * patch: Get2DSurfaceDesc
@@ -964,6 +1008,11 @@ xbox::void_xt WINAPI EMUPATCH(D3DDevice_EnableOverlay)
     bool_xt Enable
 );
 
+// ******************************************************************
+// * patch: D3DDevice_EnableOverlay_0__LTCG
+// ******************************************************************
+xbox::void_xt WINAPI EMUPATCH(D3DDevice_EnableOverlay_0__LTCG)();
+
 // ******************************************************************
 // * patch: D3DDevice_UpdateOverlay
 // ******************************************************************
@@ -976,6 +1025,17 @@ xbox::void_xt WINAPI EMUPATCH(D3DDevice_UpdateOverlay)
     D3DCOLOR      ColorKey
 );
 
+// ******************************************************************
+// * patch: D3DDevice_UpdateOverlay
+// ******************************************************************
+xbox::void_xt WINAPI EMUPATCH(D3DDevice_UpdateOverlay_16__LTCG_eax2)
+(
+    X_D3DSurface *pSurface,
+    CONST RECT   *DstRect,
+    bool_xt       EnableColorKey,
+    D3DCOLOR      ColorKey
+);
+
 // ******************************************************************
 // * patch: D3DDevice_GetOverlayUpdateStatus
 // ******************************************************************
@@ -1308,6 +1368,11 @@ xbox::void_xt WINAPI EMUPATCH(D3DDevice_MultiplyTransform)
 	CONST D3DMATRIX      *pMatrix
 );
 
+// ******************************************************************
+// * patch: D3DDevice_MultiplyTransform_0__LTCG_ebx1_eax2
+// ******************************************************************
+xbox::void_xt WINAPI EMUPATCH(D3DDevice_MultiplyTransform_0__LTCG_ebx1_eax2)();
+
 // ******************************************************************
 // * patch: D3DDevice_GetTransform
 // ******************************************************************
@@ -1357,20 +1422,20 @@ xbox::void_xt WINAPI EMUPATCH(D3DDevice_SetStreamSource)
     uint_xt                Stride
 );
 
-xbox::void_xt WINAPI EMUPATCH(D3DDevice_SetStreamSource_0__LTCG_eax_StreamNumber_edi_pStreamData_ebx_Stride)();
+xbox::void_xt WINAPI EMUPATCH(D3DDevice_SetStreamSource_0__LTCG_eax1_edi2_ebx3)();
 
-xbox::void_xt WINAPI EMUPATCH(D3DDevice_SetStreamSource_4)
+xbox::void_xt WINAPI EMUPATCH(D3DDevice_SetStreamSource_4__LTCG_eax1_ebx2)
 (
     uint_xt                Stride
 );
 
-xbox::void_xt WINAPI EMUPATCH(D3DDevice_SetStreamSource_8)
+xbox::void_xt WINAPI EMUPATCH(D3DDevice_SetStreamSource_8__LTCG_eax1)
 (
     X_D3DVertexBuffer  *pStreamData,
     uint_xt                Stride
 );
 
-xbox::void_xt __fastcall EMUPATCH(D3DDevice_SetStreamSource_8__LTCG_edx_StreamNumber)
+xbox::void_xt __fastcall EMUPATCH(D3DDevice_SetStreamSource_8__LTCG_edx1)
 (
     void*,
     uint_xt                StreamNumber,
@@ -1386,7 +1451,7 @@ xbox::void_xt WINAPI EMUPATCH(D3DDevice_SetVertexShader)
     dword_xt            Handle
 );
 
-xbox::void_xt WINAPI EMUPATCH(D3DDevice_SetVertexShader_0)();
+xbox::void_xt WINAPI EMUPATCH(D3DDevice_SetVertexShader_0__LTCG_ebx1)();
 
 // ******************************************************************
 // * patch: D3DDevice_DrawVertices
@@ -1491,6 +1556,14 @@ xbox::hresult_xt WINAPI EMUPATCH(D3DDevice_LightEnable)
     bool_xt             bEnable
 );
 
+// ******************************************************************
+// * patch: D3DDevice_LightEnable_4__LTCG_eax1
+// ******************************************************************
+xbox::hresult_xt WINAPI EMUPATCH(D3DDevice_LightEnable_4__LTCG_eax1)
+(
+    bool_xt bEnable
+);
+
 // ******************************************************************
 // * patch: D3DDevice_Release
 // ******************************************************************
@@ -1523,9 +1596,9 @@ xbox::void_xt WINAPI EMUPATCH(D3DDevice_SetRenderTarget)
 );
 
 // ******************************************************************
-// * patch: D3DDevice_SetRenderTarget_0
+// * patch: D3DDevice_SetRenderTarget_0__LTCG_ecx1_eax2
 // ******************************************************************
-xbox::void_xt WINAPI EMUPATCH(D3DDevice_SetRenderTarget_0)();
+xbox::void_xt WINAPI EMUPATCH(D3DDevice_SetRenderTarget_0__LTCG_ecx1_eax2)();
 
 // ******************************************************************
 // * patch: D3D_CommonSetRenderTarget
@@ -1546,7 +1619,7 @@ xbox::void_xt WINAPI EMUPATCH(D3DDevice_SetPalette)
     X_D3DPalette *pPalette
 );
 
-xbox::void_xt WINAPI EMUPATCH(D3DDevice_SetPalette_4)
+xbox::void_xt WINAPI EMUPATCH(D3DDevice_SetPalette_4__LTCG_eax1)
 (
     X_D3DPalette *pPalette
 );
@@ -1559,7 +1632,7 @@ xbox::void_xt WINAPI EMUPATCH(D3DDevice_SetFlickerFilter)
     dword_xt         Filter
 );
 
-xbox::void_xt WINAPI EMUPATCH(D3DDevice_SetFlickerFilter_0)();
+xbox::void_xt WINAPI EMUPATCH(D3DDevice_SetFlickerFilter_0__LTCG_esi1)();
 
 // ******************************************************************
 // * patch: D3DDevice_SetSoftDisplayFilter
@@ -1605,7 +1678,7 @@ xbox::void_xt WINAPI EMUPATCH(D3DDevice_DeleteVertexShader)
     dword_xt Handle
 );
 
-xbox::void_xt WINAPI EMUPATCH(D3DDevice_DeleteVertexShader_0)();
+xbox::void_xt WINAPI EMUPATCH(D3DDevice_DeleteVertexShader_0__LTCG_eax1)();
 
 // ******************************************************************
 // * patch: D3DDevice_GetShaderConstantMode
@@ -1662,6 +1735,14 @@ xbox::void_xt WINAPI EMUPATCH(D3DDevice_RunVertexStateShader)
     CONST float_xt *pData
 );
 
+// ******************************************************************
+// * patch: D3DDevice_RunVertexStateShader_4__LTCG_esi2
+// ******************************************************************
+xbox::void_xt WINAPI EMUPATCH(D3DDevice_RunVertexStateShader_4__LTCG_esi2)
+(
+    dword_xt Address
+);
+
 // ******************************************************************
 // * patch: D3DDevice_LoadVertexShaderProgram
 // ******************************************************************
@@ -2063,13 +2144,12 @@ void WINAPI EMUPATCH(D3D_SetCommonDebugRegisters)();
 // ******************************************************************
 // * patch: D3D_BlockOnTime
 // ******************************************************************
-void WINAPI EMUPATCH(D3D_BlockOnTime)( dword_xt Unknown1, int Unknown2 );
+void WINAPI EMUPATCH(D3D_BlockOnTime)(dword_xt Time, int MakeSpace);
 
 // ******************************************************************
-// * patch: D3D_BlockOnTime_4
-//   One of the parameters (unknown which) passed in EAX
+// * patch: D3D_BlockOnTime_4__LTCG_eax1
 // ******************************************************************
-void WINAPI EMUPATCH(D3D_BlockOnTime_4)( dword_xt Unknown1 );
+void WINAPI EMUPATCH(D3D_BlockOnTime_4__LTCG_eax1)(int MakeSpace);
 
 // ******************************************************************
 // * patch: D3D_BlockOnResource
@@ -2082,9 +2162,9 @@ void WINAPI EMUPATCH(D3D_BlockOnResource)( X_D3DResource* pResource );
 void WINAPI EMUPATCH(D3D_DestroyResource)( X_D3DResource* pResource );
 
 // ******************************************************************
-// * patch: D3D_DestroyResource__LTCG
+// * patch: D3D_DestroyResource_0__LTCG_edi1
 // ******************************************************************
-void WINAPI EMUPATCH(D3D_DestroyResource__LTCG)();
+void WINAPI EMUPATCH(D3D_DestroyResource_0__LTCG_edi1)();
 
 
 // ******************************************************************

src/core/hle/D3D8/XbVertexShader.cpp

@@ -52,6 +52,8 @@
 #include <bitset>
 #include <filesystem>
 
+#include "nv2a_vsh_emulator.h"
+
 // External symbols :
 extern xbox::X_STREAMINPUT g_Xbox_SetStreamSource[X_VSH_MAX_STREAMS]; // Declared in XbVertexBuffer.cpp
 extern XboxRenderStateConverter XboxRenderStates; // Declared in Direct3D9.cpp
@@ -1625,3 +1627,44 @@ extern void EmuParseVshFunction
 		pCurToken += X_VSH_INSTRUCTION_SIZE;
 	}
 }
+
+void CxbxrImpl_RunVertexStateShader(DWORD Address, CONST FLOAT *pData)
+{
+	// If pData is assigned, pData[0..3] is pushed towards nv2a transform data registers
+	// then sends the nv2a a command to launch the vertex shader function located at Address
+	if (Address >= NV2A_MAX_TRANSFORM_PROGRAM_LENGTH) {
+		LOG_TEST_CASE("Address out of bounds");
+		return;
+	}
+
+	NV2AState* dev = g_NV2A->GetDeviceState();
+	PGRAPHState* pg = &(dev->pgraph);
+
+	Nv2aVshProgram program = {}; // Note: This nulls program.steps
+	// TODO : Retain program globally and perform nv2a_vsh_parse_program only when
+	//        the address-range we're about to emulate was modified since last parse.
+	// TODO : As a suggestion for this, parse all NV2A_MAX_TRANSFORM_PROGRAM_LENGTH slots,
+	//        and here just point program.steps to global vsh_program_steps[Address].
+	Nv2aVshParseResult result = nv2a_vsh_parse_program(
+		&program, // Note : program.steps will be malloc'ed
+		GetCxbxVertexShaderSlotPtr(Address), // TODO : At some point, use pg->program_data[Address] here instead
+		NV2A_MAX_TRANSFORM_PROGRAM_LENGTH - Address);
+	if (result != NV2AVPR_SUCCESS) {
+		LOG_TEST_CASE("nv2a_vsh_parse_program failed");
+		// TODO : Dump Nv2aVshParseResult as string and program for debugging purposes
+		return;
+	}
+
+	Nv2aVshCPUXVSSExecutionState state_linkage;
+	Nv2aVshExecutionState state = nv2a_vsh_emu_initialize_xss_execution_state(
+		&state_linkage, (float*)pg->vsh_constants); // Note : This wil memset(state_linkage, 0)
+	if (pData != nullptr)
+		//if pData != nullptr, then it contains v0.xyzw, we shall copy the binary content directly.
+		memcpy(state_linkage.input_regs, pData, sizeof(state_linkage.input_regs));
+
+	nv2a_vsh_emu_execute_track_context_writes(&state, &program, pg->vsh_constants_dirty);
+	// Note: Above emulation's primary purpose is to update pg->vsh_constants and pg->vsh_constants_dirty
+	// therefor, nothing else needs to be done here, other than to cleanup
+
+	nv2a_vsh_program_destroy(&program); // Note: program.steps will be free'ed
+}

src/core/hle/D3D8/XbVertexShader.h

@@ -252,5 +252,6 @@ extern void CxbxImpl_SelectVertexShader(DWORD Handle, DWORD Address);
 extern void CxbxImpl_SetVertexShaderInput(DWORD Handle, UINT StreamCount, xbox::X_STREAMINPUT* pStreamInputs);
 extern void CxbxImpl_SetVertexShaderConstant(INT Register, PVOID pConstantData, DWORD ConstantCount);
 extern void CxbxImpl_DeleteVertexShader(DWORD Handle);
+extern void CxbxrImpl_RunVertexStateShader(DWORD Address, CONST FLOAT* pData);
 extern void CxbxVertexShaderSetFlags();
 #endif

src/core/hle/Intercept.cpp

@@ -208,8 +208,12 @@ void CDECL EmuRegisterSymbol(const char* library_str,
                              uint32_t library_flag,
                              uint32_t xref_index,
                              const char* symbol_str,
-                             uint32_t func_addr,
-                             uint32_t revision)
+                             xbaddr symbol_addr,
+                             uint32_t build_version,
+                             uint32_t symbol_type,
+                             uint32_t call_type,
+                             uint32_t param_count,
+                             const XbSDBSymbolParam* param_list)
 {
     // Ignore registered symbol in current database.
     uint32_t hasSymbol = g_SymbolAddresses[symbol_str];
@@ -218,8 +222,8 @@ void CDECL EmuRegisterSymbol(const char* library_str,
 
     // Output some details
     std::stringstream output;
-    output << "Symbol: 0x" << std::setfill('0') << std::setw(8) << std::hex << func_addr
-        << " -> " << symbol_str << " " << std::dec << revision;
+    output << "Symbol: 0x" << std::setfill('0') << std::setw(8) << std::hex << symbol_addr
+        << " -> " << symbol_str << " " << std::dec << build_version;
 
 #if 0 // TODO: XbSymbolDatabase - Need to create a structure for patch and stuff.
     bool IsXRef = OovpaTable->Oovpa->XRefSaveIndex != XRefNoSaveIndex;
@@ -286,7 +290,7 @@ void CDECL EmuRegisterSymbol(const char* library_str,
 
 	output << "\n";
 
-	g_SymbolAddresses[symbol_str] = func_addr;
+	g_SymbolAddresses[symbol_str] = symbol_addr;
     printf(output.str().c_str());
 }
 
@@ -297,22 +301,22 @@ void EmuUpdateLLEStatus(uint32_t XbLibScan)
     g_EmuShared->GetFlagsLLE(&FlagsLLE);
 
     if ((FlagsLLE & LLE_GPU) == false
-        && !((XbLibScan & XbSymbolLib_D3D8) > 0
-            || (XbLibScan & XbSymbolLib_D3D8LTCG) > 0)) {
+        && !((XbLibScan & XBSDBLIB_D3D8) > 0
+            || (XbLibScan & XBSDBLIB_D3D8LTCG) > 0)) {
         bLLE_GPU = true;
         FlagsLLE ^= LLE_GPU;
         EmuOutputMessage(XB_OUTPUT_MESSAGE_INFO, "Fallback to LLE GPU.");
     }
 
     if ((FlagsLLE & LLE_APU) == false
-        && (XbLibScan & XbSymbolLib_DSOUND) == 0) {
+        && (XbLibScan & XBSDBLIB_DSOUND) == 0) {
         bLLE_APU = true;
         FlagsLLE ^= LLE_APU;
         EmuOutputMessage(XB_OUTPUT_MESSAGE_INFO, "Fallback to LLE APU.");
     }
 #if 0 // Reenable this when LLE USB actually works
 	if ((FlagsLLE & LLE_USB) == false
-		&& (XbLibScan & XbSymbolLib_XAPILIB) == 0) {
+		&& (XbLibScan & XBSDBLIB_XAPILIB) == 0) {
 		bLLE_USB = true;
 		FlagsLLE ^= LLE_USB;
 		EmuOutputMessage(XB_OUTPUT_MESSAGE_INFO, "Fallback to LLE USB.");
@@ -346,16 +350,16 @@ void EmuHLEIntercept(Xbe::Header *pXbeHeader)
 			if (xdkVersion < BuildVersion) {
 				xdkVersion = BuildVersion;
 			}
-			XbLibFlag = XbSymbolDatabase_LibraryToFlag(std::string(pLibraryVersion[v].szName, pLibraryVersion[v].szName + 8).c_str());
+			XbLibFlag = XbSDB_LibraryToFlag(std::string(pLibraryVersion[v].szName, pLibraryVersion[v].szName + 8).c_str());
 			XbLibScan |= XbLibFlag;
 
 			// Keep certain library versions for plugin usage.
-			if ((XbLibFlag & (XbSymbolLib_D3D8 | XbSymbolLib_D3D8LTCG)) > 0) {
+			if ((XbLibFlag & (XBSDBLIB_D3D8 | XBSDBLIB_D3D8LTCG)) > 0) {
 				if (g_LibVersion_D3D8 < BuildVersion) {
 					g_LibVersion_D3D8 = BuildVersion;
 				}
 			}
-			else if ((XbLibFlag & XbSymbolLib_DSOUND) > 0) {
+			else if ((XbLibFlag & XBSDBLIB_DSOUND) > 0) {
 				g_LibVersion_DSOUND = BuildVersion;
 			}
 		}
@@ -363,8 +367,8 @@ void EmuHLEIntercept(Xbe::Header *pXbeHeader)
 		// Since XDK 4039 title does not have library version for DSOUND, let's check section header if it exists or not.
 		for (unsigned int v = 0; v < pXbeHeader->dwSections; v++) {
 			SectionName = (const char*)pSectionHeaders[v].dwSectionNameAddr;
-			if (strncmp(SectionName, Lib_DSOUND, 8) == 0) {
-				XbLibScan |= XbSymbolLib_DSOUND;
+			if (strncmp(SectionName, LIB_DSOUND, 8) == 0) {
+				XbLibScan |= XBSDBLIB_DSOUND;
 
 				// If DSOUND version is not set, we need to force set it.
 				if (g_LibVersion_DSOUND == 0) {
@@ -417,7 +421,7 @@ void EmuHLEIntercept(Xbe::Header *pXbeHeader)
 		// Verify the version of the cache file against the Symbol Database version hash
 		const uint32_t SymbolDatabaseVersionHash = symbolCacheData.GetLongValue(section_info, sect_info_keys.SymbolDatabaseVersionHash, /*Default=*/0);
 
-		if (SymbolDatabaseVersionHash == XbSymbolDatabase_LibraryVersion()) {
+		if (SymbolDatabaseVersionHash == XbSDB_LibraryVersion()) {
 			g_SymbolCacheUsed = true;
 			CSimpleIniA::TNamesDepend symbol_names;
 
@@ -488,9 +492,9 @@ void EmuHLEIntercept(Xbe::Header *pXbeHeader)
         }
 #endif
 
-		XbSymbolDatabase_SetOutputMessage(EmuOutputMessage);
+        XbSDB_SetOutputMessage(EmuOutputMessage);
 
-		XbSymbolScan(pXbeHeader, EmuRegisterSymbol, false);
+        XbSDB_Scan(pXbeHeader, EmuRegisterSymbol, false);
 	}
 
 	std::printf("\n");
@@ -499,7 +503,7 @@ void EmuHLEIntercept(Xbe::Header *pXbeHeader)
 	symbolCacheData.Reset();
 
 	// Store Symbol Database version
-	symbolCacheData.SetLongValue(section_info, sect_info_keys.SymbolDatabaseVersionHash, XbSymbolDatabase_LibraryVersion(), nullptr, /*UseHex =*/false);
+	symbolCacheData.SetLongValue(section_info, sect_info_keys.SymbolDatabaseVersionHash, XbSDB_LibraryVersion(), nullptr, /*UseHex =*/false);
 
 	// Store Certificate Details
 	symbolCacheData.SetValue(section_certificate, sect_certificate_keys.Name, tAsciiTitle);

src/core/hle/JVS/JVS.cpp

@@ -209,8 +209,8 @@ void JVS_Init()
 	// Determine which version of JVS_SendCommand this title is using and derive the offset
 	// TODO: Extract this into a function and also locate PINSB
 	static int JvsSendCommandVersion = -1;
-	g_pPINSA = nullptr;
-	g_pPINSB = nullptr;
+	g_pPINSA = (DWORD*)GetXboxSymbolPointer("JVS_g_pPINSA");
+	g_pPINSB = (DWORD*)GetXboxSymbolPointer("JVS_g_pPINSB");
 
 	auto JvsSendCommandOffset1 = (uintptr_t)GetXboxSymbolPointer("JVS_SendCommand");
 	auto JvsSendCommandOffset2 = (uintptr_t)GetXboxSymbolPointer("JVS_SendCommand2");
@@ -218,26 +218,14 @@ void JVS_Init()
 
 	if (JvsSendCommandOffset1) {
 		JvsSendCommandVersion = 1;
-		g_pPINSA = *(DWORD**)(JvsSendCommandOffset1 + 0x2A0);
-		g_pPINSB = (DWORD*)((DWORD)g_pPINSA - 8);
 	}
 
 	if (JvsSendCommandOffset2) {
 		JvsSendCommandVersion = 2;
-		g_pPINSA = *(DWORD**)(JvsSendCommandOffset2 + 0x312);
-		g_pPINSB = (DWORD*)((DWORD)g_pPINSA - 8);
 	}
 
 	if (JvsSendCommandOffset3) {
 		JvsSendCommandVersion = 3;
-		g_pPINSA = *(DWORD**)(JvsSendCommandOffset3 + 0x307);
-		g_pPINSB = (DWORD*)((DWORD)g_pPINSA - 8);
-
-		if ((DWORD)g_pPINSA > XBE_MAX_VA) { 
-			// This was invalid, we must have the other varient of SendCommand3 (SEGABOOT)
-			g_pPINSA = *(DWORD**)(JvsSendCommandOffset3 + 0x302);
-			g_pPINSB = (DWORD*)((DWORD)g_pPINSA - 8);
-		}
 	}
 
 	// Set state to a sane initial default

src/core/hle/Patches.cpp

@@ -72,7 +72,7 @@ std::map<const std::string, const xbox_patch_t> g_PatchTable = {
     PATCH_ENTRY("D3DDevice_CopyRects", xbox::EMUPATCH(D3DDevice_CopyRects), PATCH_HLE_D3D),
 	// PATCH_ENTRY("D3DDevice_CreateVertexShader", xbox::EMUPATCH(D3DDevice_CreateVertexShader), PATCH_HLE_D3D),
 	PATCH_ENTRY("D3DDevice_DeleteVertexShader", xbox::EMUPATCH(D3DDevice_DeleteVertexShader), PATCH_HLE_D3D),
-	PATCH_ENTRY("D3DDevice_DeleteVertexShader_0", xbox::EMUPATCH(D3DDevice_DeleteVertexShader_0), PATCH_HLE_D3D),
+	PATCH_ENTRY("D3DDevice_DeleteVertexShader_0__LTCG_eax1", xbox::EMUPATCH(D3DDevice_DeleteVertexShader_0__LTCG_eax1), PATCH_HLE_D3D),
 	PATCH_ENTRY("D3DDevice_DrawIndexedVertices", xbox::EMUPATCH(D3DDevice_DrawIndexedVertices), PATCH_HLE_D3D),
 	PATCH_ENTRY("D3DDevice_DrawIndexedVerticesUP", xbox::EMUPATCH(D3DDevice_DrawIndexedVerticesUP), PATCH_HLE_D3D),
 	PATCH_ENTRY("D3DDevice_DrawRectPatch", xbox::EMUPATCH(D3DDevice_DrawRectPatch), PATCH_HLE_D3D),
@@ -83,12 +83,14 @@ std::map<const std::string, const xbox_patch_t> g_PatchTable = {
 	PATCH_ENTRY("D3DDevice_DrawVerticesUP", xbox::EMUPATCH(D3DDevice_DrawVerticesUP), PATCH_HLE_D3D),
 	PATCH_ENTRY("D3DDevice_DrawVerticesUP_12__LTCG_ebx3", xbox::EMUPATCH(D3DDevice_DrawVerticesUP_12__LTCG_ebx3), PATCH_HLE_D3D),
 	PATCH_ENTRY("D3DDevice_EnableOverlay", xbox::EMUPATCH(D3DDevice_EnableOverlay), PATCH_HLE_D3D),
+	PATCH_ENTRY("D3DDevice_EnableOverlay_0__LTCG", xbox::EMUPATCH(D3DDevice_EnableOverlay_0__LTCG), PATCH_HLE_D3D),
 	PATCH_ENTRY("D3DDevice_End", xbox::EMUPATCH(D3DDevice_End), PATCH_HLE_D3D),
 	PATCH_ENTRY("D3DDevice_EndPush", xbox::EMUPATCH(D3DDevice_EndPush), PATCH_HLE_D3D),
 	PATCH_ENTRY("D3DDevice_EndVisibilityTest", xbox::EMUPATCH(D3DDevice_EndVisibilityTest), PATCH_HLE_D3D),
-	PATCH_ENTRY("D3DDevice_EndVisibilityTest_0", xbox::EMUPATCH(D3DDevice_EndVisibilityTest_0), PATCH_HLE_D3D),
+	PATCH_ENTRY("D3DDevice_EndVisibilityTest_0__LTCG_eax1", xbox::EMUPATCH(D3DDevice_EndVisibilityTest_0__LTCG_eax1), PATCH_HLE_D3D),
 	PATCH_ENTRY("D3DDevice_FlushVertexCache", xbox::EMUPATCH(D3DDevice_FlushVertexCache), PATCH_HLE_D3D),
 	PATCH_ENTRY("D3DDevice_GetBackBuffer", xbox::EMUPATCH(D3DDevice_GetBackBuffer), PATCH_HLE_D3D),
+	PATCH_ENTRY("D3DDevice_GetBackBuffer_8__LTCG_eax1", xbox::EMUPATCH(D3DDevice_GetBackBuffer_8__LTCG_eax1), PATCH_HLE_D3D),
 	PATCH_ENTRY("D3DDevice_GetBackBuffer2", xbox::EMUPATCH(D3DDevice_GetBackBuffer2), PATCH_HLE_D3D),
 	PATCH_ENTRY("D3DDevice_GetBackBuffer2_0__LTCG_eax1", xbox::EMUPATCH(D3DDevice_GetBackBuffer2_0__LTCG_eax1), PATCH_HLE_D3D),
 	PATCH_ENTRY("D3DDevice_GetDisplayFieldStatus", xbox::EMUPATCH(D3DDevice_GetDisplayFieldStatus), PATCH_HLE_D3D),
@@ -107,18 +109,21 @@ std::map<const std::string, const xbox_patch_t> g_PatchTable = {
 	//PATCH_ENTRY("D3DDevice_GetVertexShaderSize", xbox::EMUPATCH(D3DDevice_GetVertexShaderSize), PATCH_HLE_D3D),
 	//PATCH_ENTRY("D3DDevice_GetVertexShaderType", xbox::EMUPATCH(D3DDevice_GetVertexShaderType), PATCH_HLE_D3D),
 	//PATCH_ENTRY("D3DDevice_GetViewportOffsetAndScale", xbox::EMUPATCH(D3DDevice_GetViewportOffsetAndScale), PATCH_HLE_D3D),
+	//PATCH_ENTRY("D3DDevice_GetViewportOffsetAndScale_0__LTCG_edx1_ecx2", xbox::EMUPATCH(D3DDevice_GetViewportOffsetAndScale_0__LTCG_edx1_ecx2), PATCH_HLE_D3D),
 	PATCH_ENTRY("D3DDevice_GetVisibilityTestResult", xbox::EMUPATCH(D3DDevice_GetVisibilityTestResult), PATCH_HLE_D3D),
 	PATCH_ENTRY("D3DDevice_InsertCallback", xbox::EMUPATCH(D3DDevice_InsertCallback), PATCH_HLE_D3D),
 	PATCH_ENTRY("D3DDevice_InsertFence", xbox::EMUPATCH(D3DDevice_InsertFence), PATCH_HLE_D3D),
 	PATCH_ENTRY("D3DDevice_IsBusy", xbox::EMUPATCH(D3DDevice_IsBusy), PATCH_HLE_D3D),
 	PATCH_ENTRY("D3DDevice_IsFencePending", xbox::EMUPATCH(D3DDevice_IsFencePending), PATCH_HLE_D3D),
 	PATCH_ENTRY("D3DDevice_LightEnable", xbox::EMUPATCH(D3DDevice_LightEnable), PATCH_HLE_D3D),
+	PATCH_ENTRY("D3DDevice_LightEnable_4__LTCG_eax1", xbox::EMUPATCH(D3DDevice_LightEnable_4__LTCG_eax1), PATCH_HLE_D3D),
 	PATCH_ENTRY("D3DDevice_LoadVertexShader", xbox::EMUPATCH(D3DDevice_LoadVertexShader), PATCH_HLE_D3D),
 	PATCH_ENTRY("D3DDevice_LoadVertexShaderProgram", xbox::EMUPATCH(D3DDevice_LoadVertexShaderProgram), PATCH_HLE_D3D),
-	PATCH_ENTRY("D3DDevice_LoadVertexShader_0__LTCG_eax_Address_ecx_Handle", xbox::EMUPATCH(D3DDevice_LoadVertexShader_0__LTCG_eax_Address_ecx_Handle), PATCH_HLE_D3D),
-	PATCH_ENTRY("D3DDevice_LoadVertexShader_0__LTCG_eax_Address_edx_Handle", xbox::EMUPATCH(D3DDevice_LoadVertexShader_0__LTCG_eax_Address_edx_Handle), PATCH_HLE_D3D),
-	PATCH_ENTRY("D3DDevice_LoadVertexShader_4", xbox::EMUPATCH(D3DDevice_LoadVertexShader_4), PATCH_HLE_D3D),
+	PATCH_ENTRY("D3DDevice_LoadVertexShader_0__LTCG_ecx1_eax2", xbox::EMUPATCH(D3DDevice_LoadVertexShader_0__LTCG_ecx1_eax2), PATCH_HLE_D3D),
+	PATCH_ENTRY("D3DDevice_LoadVertexShader_0__LTCG_edx1_eax2", xbox::EMUPATCH(D3DDevice_LoadVertexShader_0__LTCG_edx1_eax2), PATCH_HLE_D3D),
+	PATCH_ENTRY("D3DDevice_LoadVertexShader_4__LTCG_eax1", xbox::EMUPATCH(D3DDevice_LoadVertexShader_4__LTCG_eax1), PATCH_HLE_D3D),
 	PATCH_ENTRY("D3DDevice_MultiplyTransform", xbox::EMUPATCH(D3DDevice_MultiplyTransform), PATCH_HLE_D3D),
+	PATCH_ENTRY("D3DDevice_MultiplyTransform_0__LTCG_ebx1_eax2", xbox::EMUPATCH(D3DDevice_MultiplyTransform_0__LTCG_ebx1_eax2), PATCH_HLE_D3D),
 	PATCH_ENTRY("D3DDevice_PersistDisplay", xbox::EMUPATCH(D3DDevice_PersistDisplay), PATCH_HLE_D3D),
 	PATCH_ENTRY("D3DDevice_Present", xbox::EMUPATCH(D3DDevice_Present), PATCH_HLE_D3D),
 	PATCH_ENTRY("D3DDevice_PrimeVertexCache", xbox::EMUPATCH(D3DDevice_PrimeVertexCache), PATCH_HLE_D3D),
@@ -126,84 +131,92 @@ std::map<const std::string, const xbox_patch_t> g_PatchTable = {
 	PATCH_ENTRY("D3DDevice_Reset_0__LTCG_edi1", xbox::EMUPATCH(D3DDevice_Reset_0__LTCG_edi1), PATCH_HLE_D3D),
 	PATCH_ENTRY("D3DDevice_Reset_0__LTCG_ebx1", xbox::EMUPATCH(D3DDevice_Reset_0__LTCG_ebx1), PATCH_HLE_D3D),
 	PATCH_ENTRY("D3DDevice_RunPushBuffer", xbox::EMUPATCH(D3DDevice_RunPushBuffer), PATCH_HLE_D3D),
+	PATCH_ENTRY("D3DDevice_RunPushBuffer_4__LTCG_eax2", xbox::EMUPATCH(D3DDevice_RunPushBuffer_4__LTCG_eax2), PATCH_HLE_D3D),
 	PATCH_ENTRY("D3DDevice_RunVertexStateShader", xbox::EMUPATCH(D3DDevice_RunVertexStateShader), PATCH_HLE_D3D),
+	PATCH_ENTRY("D3DDevice_RunVertexStateShader_4__LTCG_esi2", xbox::EMUPATCH(D3DDevice_RunVertexStateShader_4__LTCG_esi2), PATCH_HLE_D3D),
 	PATCH_ENTRY("D3DDevice_SelectVertexShader", xbox::EMUPATCH(D3DDevice_SelectVertexShader), PATCH_HLE_D3D),
 	//PATCH_ENTRY("D3DDevice_SelectVertexShaderDirect", xbox::EMUPATCH(D3DDevice_SelectVertexShaderDirect), PATCH_HLE_D3D),
+	//PATCH_ENTRY("D3DDevice_SelectVertexShaderDirect_0__LTCG_eax1_ebx2", xbox::EMUPATCH(D3DDevice_SelectVertexShaderDirect_0__LTCG_eax1_ebx2), PATCH_HLE_D3D),
 	PATCH_ENTRY("D3DDevice_SelectVertexShader_0__LTCG_eax1_ebx2", xbox::EMUPATCH(D3DDevice_SelectVertexShader_0__LTCG_eax1_ebx2), PATCH_HLE_D3D),
 	PATCH_ENTRY("D3DDevice_SelectVertexShader_4__LTCG_eax1", xbox::EMUPATCH(D3DDevice_SelectVertexShader_4__LTCG_eax1), PATCH_HLE_D3D),
 	PATCH_ENTRY("D3DDevice_SetBackBufferScale", xbox::EMUPATCH(D3DDevice_SetBackBufferScale), PATCH_HLE_D3D),
 	PATCH_ENTRY("D3DDevice_SetDepthClipPlanes", xbox::EMUPATCH(D3DDevice_SetDepthClipPlanes), PATCH_HLE_D3D),
-	PATCH_ENTRY("D3DDevice_SetFlickerFilter", xbox::EMUPATCH(D3DDevice_SetFlickerFilter), PATCH_HLE_D3D),
-	PATCH_ENTRY("D3DDevice_SetFlickerFilter_0", xbox::EMUPATCH(D3DDevice_SetFlickerFilter_0), PATCH_HLE_D3D),
+	//PATCH_ENTRY("D3DDevice_SetFlickerFilter", xbox::EMUPATCH(D3DDevice_SetFlickerFilter), PATCH_HLE_D3D),
+	//PATCH_ENTRY("D3DDevice_SetFlickerFilter_0__LTCG_esi1", xbox::EMUPATCH(D3DDevice_SetFlickerFilter_0__LTCG_esi1), PATCH_HLE_D3D),
 	PATCH_ENTRY("D3DDevice_SetGammaRamp", xbox::EMUPATCH(D3DDevice_SetGammaRamp), PATCH_HLE_D3D),
 	PATCH_ENTRY("D3DDevice_SetIndices", xbox::EMUPATCH(D3DDevice_SetIndices), PATCH_HLE_D3D),
-    PATCH_ENTRY("D3DDevice_SetIndices_4", xbox::EMUPATCH(D3DDevice_SetIndices_4), PATCH_HLE_D3D),
+	PATCH_ENTRY("D3DDevice_SetIndices_4__LTCG_ebx1", xbox::EMUPATCH(D3DDevice_SetIndices_4__LTCG_ebx1), PATCH_HLE_D3D),
 	PATCH_ENTRY("D3DDevice_SetLight", xbox::EMUPATCH(D3DDevice_SetLight), PATCH_HLE_D3D),
 	PATCH_ENTRY("D3DDevice_SetMaterial", xbox::EMUPATCH(D3DDevice_SetMaterial), PATCH_HLE_D3D),
 	PATCH_ENTRY("D3DDevice_SetModelView", xbox::EMUPATCH(D3DDevice_SetModelView), PATCH_HLE_D3D),
 	PATCH_ENTRY("D3DDevice_SetPalette", xbox::EMUPATCH(D3DDevice_SetPalette), PATCH_HLE_D3D),
-	PATCH_ENTRY("D3DDevice_SetPalette_4", xbox::EMUPATCH(D3DDevice_SetPalette_4), PATCH_HLE_D3D),
+	PATCH_ENTRY("D3DDevice_SetPalette_4__LTCG_eax1", xbox::EMUPATCH(D3DDevice_SetPalette_4__LTCG_eax1), PATCH_HLE_D3D),
 	PATCH_ENTRY("D3DDevice_SetPixelShader", xbox::EMUPATCH(D3DDevice_SetPixelShader), PATCH_HLE_D3D),
-	//PATCH_ENTRY("D3DDevice_SetPixelShaderConstant_4", xbox::EMUPATCH(D3DDevice_SetPixelShaderConstant_4), PATCH_HLE_D3D),
-	PATCH_ENTRY("D3DDevice_SetPixelShader_0__LTCG_eax_handle", xbox::EMUPATCH(D3DDevice_SetPixelShader_0__LTCG_eax_handle), PATCH_HLE_D3D),
+	//PATCH_ENTRY("D3DDevice_SetPixelShaderConstant", xbox::EMUPATCH(D3DDevice_SetPixelShaderConstant), PATCH_HLE_D3D),
+	//PATCH_ENTRY("D3DDevice_SetPixelShaderConstant_4__LTCG_ecx1_eax3", xbox::EMUPATCH(D3DDevice_SetPixelShaderConstant_4__LTCG_ecx1_eax3), PATCH_HLE_D3D),
+	PATCH_ENTRY("D3DDevice_SetPixelShader_0__LTCG_eax1", xbox::EMUPATCH(D3DDevice_SetPixelShader_0__LTCG_eax1), PATCH_HLE_D3D),
 	PATCH_ENTRY("D3DDevice_SetRenderState_Simple", xbox::EMUPATCH(D3DDevice_SetRenderState_Simple), PATCH_HLE_D3D),
 	PATCH_ENTRY("D3DDevice_SetRenderTarget", xbox::EMUPATCH(D3DDevice_SetRenderTarget), PATCH_HLE_D3D),
 	PATCH_ENTRY("D3DDevice_SetRenderTargetFast", xbox::EMUPATCH(D3DDevice_SetRenderTargetFast), PATCH_HLE_D3D),
-	PATCH_ENTRY("D3DDevice_SetRenderTarget_0", xbox::EMUPATCH(D3DDevice_SetRenderTarget_0), PATCH_HLE_D3D),
+	PATCH_ENTRY("D3DDevice_SetRenderTarget_0__LTCG_ecx1_eax2", xbox::EMUPATCH(D3DDevice_SetRenderTarget_0__LTCG_ecx1_eax2), PATCH_HLE_D3D),
 	PATCH_ENTRY("D3DDevice_SetScreenSpaceOffset", xbox::EMUPATCH(D3DDevice_SetScreenSpaceOffset), PATCH_HLE_D3D),
 	PATCH_ENTRY("D3DDevice_SetShaderConstantMode", xbox::EMUPATCH(D3DDevice_SetShaderConstantMode), PATCH_HLE_D3D),
 	PATCH_ENTRY("D3DDevice_SetShaderConstantMode_0__LTCG_eax1", xbox::EMUPATCH(D3DDevice_SetShaderConstantMode_0__LTCG_eax1), PATCH_HLE_D3D),
-	PATCH_ENTRY("D3DDevice_SetSoftDisplayFilter", xbox::EMUPATCH(D3DDevice_SetSoftDisplayFilter), PATCH_HLE_D3D),
+	//PATCH_ENTRY("D3DDevice_SetSoftDisplayFilter", xbox::EMUPATCH(D3DDevice_SetSoftDisplayFilter), PATCH_HLE_D3D),
 	PATCH_ENTRY("D3DDevice_SetStipple", xbox::EMUPATCH(D3DDevice_SetStipple), PATCH_HLE_D3D),
 	PATCH_ENTRY("D3DDevice_SetStreamSource", xbox::EMUPATCH(D3DDevice_SetStreamSource), PATCH_HLE_D3D),
-	PATCH_ENTRY("D3DDevice_SetStreamSource_0__LTCG_eax_StreamNumber_edi_pStreamData_ebx_Stride", xbox::EMUPATCH(D3DDevice_SetStreamSource_0__LTCG_eax_StreamNumber_edi_pStreamData_ebx_Stride), PATCH_HLE_D3D),
-	PATCH_ENTRY("D3DDevice_SetStreamSource_4", xbox::EMUPATCH(D3DDevice_SetStreamSource_4), PATCH_HLE_D3D),
-	PATCH_ENTRY("D3DDevice_SetStreamSource_8", xbox::EMUPATCH(D3DDevice_SetStreamSource_8), PATCH_HLE_D3D),
-	PATCH_ENTRY("D3DDevice_SetStreamSource_8__LTCG_edx_StreamNumber", xbox::EMUPATCH(D3DDevice_SetStreamSource_8__LTCG_edx_StreamNumber), PATCH_HLE_D3D),
+	PATCH_ENTRY("D3DDevice_SetStreamSource_0__LTCG_eax1_edi2_ebx3", xbox::EMUPATCH(D3DDevice_SetStreamSource_0__LTCG_eax1_edi2_ebx3), PATCH_HLE_D3D),
+	PATCH_ENTRY("D3DDevice_SetStreamSource_4__LTCG_eax1_ebx2", xbox::EMUPATCH(D3DDevice_SetStreamSource_4__LTCG_eax1_ebx2), PATCH_HLE_D3D),
+	PATCH_ENTRY("D3DDevice_SetStreamSource_8__LTCG_eax1", xbox::EMUPATCH(D3DDevice_SetStreamSource_8__LTCG_eax1), PATCH_HLE_D3D),
+	PATCH_ENTRY("D3DDevice_SetStreamSource_8__LTCG_edx1", xbox::EMUPATCH(D3DDevice_SetStreamSource_8__LTCG_edx1), PATCH_HLE_D3D),
 	PATCH_ENTRY("D3DDevice_SetSwapCallback", xbox::EMUPATCH(D3DDevice_SetSwapCallback), PATCH_HLE_D3D),
 	PATCH_ENTRY("D3DDevice_SetTexture", xbox::EMUPATCH(D3DDevice_SetTexture), PATCH_HLE_D3D),
-	PATCH_ENTRY("D3DDevice_SetTexture_4__LTCG_eax_pTexture", xbox::EMUPATCH(D3DDevice_SetTexture_4__LTCG_eax_pTexture), PATCH_HLE_D3D),
-	PATCH_ENTRY("D3DDevice_SetTexture_4__LTCG_eax_Stage", xbox::EMUPATCH(D3DDevice_SetTexture_4__LTCG_eax_Stage), PATCH_HLE_D3D),
+	PATCH_ENTRY("D3DDevice_SetTexture_4__LTCG_eax2", xbox::EMUPATCH(D3DDevice_SetTexture_4__LTCG_eax2), PATCH_HLE_D3D),
+	PATCH_ENTRY("D3DDevice_SetTexture_4__LTCG_eax1", xbox::EMUPATCH(D3DDevice_SetTexture_4__LTCG_eax1), PATCH_HLE_D3D),
 	PATCH_ENTRY("D3DDevice_SetTransform", xbox::EMUPATCH(D3DDevice_SetTransform), PATCH_HLE_D3D),
 	PATCH_ENTRY("D3DDevice_SetTransform_0__LTCG_eax1_edx2", xbox::EMUPATCH(D3DDevice_SetTransform_0__LTCG_eax1_edx2), PATCH_HLE_D3D),
 	PATCH_ENTRY("D3DDevice_SetVertexData2f", xbox::EMUPATCH(D3DDevice_SetVertexData2f), PATCH_HLE_D3D),
 	PATCH_ENTRY("D3DDevice_SetVertexData2s", xbox::EMUPATCH(D3DDevice_SetVertexData2s), PATCH_HLE_D3D),
 	PATCH_ENTRY("D3DDevice_SetVertexData4f", xbox::EMUPATCH(D3DDevice_SetVertexData4f), PATCH_HLE_D3D),
-	PATCH_ENTRY("D3DDevice_SetVertexData4f_16", xbox::EMUPATCH(D3DDevice_SetVertexData4f_16), PATCH_HLE_D3D),
+	PATCH_ENTRY("D3DDevice_SetVertexData4f_16__LTCG_edi1", xbox::EMUPATCH(D3DDevice_SetVertexData4f_16__LTCG_edi1), PATCH_HLE_D3D),
 	PATCH_ENTRY("D3DDevice_SetVertexData4s", xbox::EMUPATCH(D3DDevice_SetVertexData4s), PATCH_HLE_D3D),
 	PATCH_ENTRY("D3DDevice_SetVertexData4ub", xbox::EMUPATCH(D3DDevice_SetVertexData4ub), PATCH_HLE_D3D),
 	PATCH_ENTRY("D3DDevice_SetVertexDataColor", xbox::EMUPATCH(D3DDevice_SetVertexDataColor), PATCH_HLE_D3D),
 	PATCH_ENTRY("D3DDevice_SetVertexShader", xbox::EMUPATCH(D3DDevice_SetVertexShader), PATCH_HLE_D3D),
-	PATCH_ENTRY("D3DDevice_SetVertexShader_0", xbox::EMUPATCH(D3DDevice_SetVertexShader_0), PATCH_HLE_D3D),
+	PATCH_ENTRY("D3DDevice_SetVertexShader_0__LTCG_ebx1", xbox::EMUPATCH(D3DDevice_SetVertexShader_0__LTCG_ebx1), PATCH_HLE_D3D),
 	PATCH_ENTRY("D3DDevice_SetVertexShaderConstant", xbox::EMUPATCH(D3DDevice_SetVertexShaderConstant), PATCH_HLE_D3D),
 	PATCH_ENTRY("D3DDevice_SetVertexShaderConstant1", xbox::EMUPATCH(D3DDevice_SetVertexShaderConstant1), PATCH_HLE_D3D),
 	PATCH_ENTRY("D3DDevice_SetVertexShaderConstant1Fast", xbox::EMUPATCH(D3DDevice_SetVertexShaderConstant1Fast), PATCH_HLE_D3D),
 	PATCH_ENTRY("D3DDevice_SetVertexShaderConstant4", xbox::EMUPATCH(D3DDevice_SetVertexShaderConstant4), PATCH_HLE_D3D),
 	PATCH_ENTRY("D3DDevice_SetVertexShaderConstantNotInline", xbox::EMUPATCH(D3DDevice_SetVertexShaderConstantNotInline), PATCH_HLE_D3D),
+	PATCH_ENTRY("D3DDevice_SetVertexShaderConstantNotInline_0__LTCG_ebx1_edx2_eax3", xbox::EMUPATCH(D3DDevice_SetVertexShaderConstantNotInline_0__LTCG_ebx1_edx2_eax3), PATCH_HLE_D3D),
 	PATCH_ENTRY("D3DDevice_SetVertexShaderConstantNotInlineFast", xbox::EMUPATCH(D3DDevice_SetVertexShaderConstantNotInlineFast), PATCH_HLE_D3D),
-	PATCH_ENTRY("D3DDevice_SetVertexShaderConstant_8", xbox::EMUPATCH(D3DDevice_SetVertexShaderConstant_8), PATCH_HLE_D3D),
+	PATCH_ENTRY("D3DDevice_SetVertexShaderConstant_8__LTCG_edx3", xbox::EMUPATCH(D3DDevice_SetVertexShaderConstant_8__LTCG_edx3), PATCH_HLE_D3D),
 	PATCH_ENTRY("D3DDevice_SetVertexShaderInput", xbox::EMUPATCH(D3DDevice_SetVertexShaderInput), PATCH_HLE_D3D),
 	//PATCH_ENTRY("D3DDevice_SetVertexShaderInputDirect", xbox::EMUPATCH(D3DDevice_SetVertexShaderInputDirect), PATCH_HLE_D3D),
 	//PATCH_ENTRY("D3DDevice_SetVerticalBlankCallback", xbox::EMUPATCH(D3DDevice_SetVerticalBlankCallback), PATCH_HLE_D3D),
 	PATCH_ENTRY("D3DDevice_SetViewport", xbox::EMUPATCH(D3DDevice_SetViewport), PATCH_HLE_D3D),
 	PATCH_ENTRY("D3DDevice_Swap", xbox::EMUPATCH(D3DDevice_Swap), PATCH_HLE_D3D),
-	PATCH_ENTRY("D3DDevice_Swap_0", xbox::EMUPATCH(D3DDevice_Swap_0), PATCH_HLE_D3D),
+	PATCH_ENTRY("D3DDevice_Swap_0__LTCG_eax1", xbox::EMUPATCH(D3DDevice_Swap_0__LTCG_eax1), PATCH_HLE_D3D),
 	PATCH_ENTRY("D3DDevice_SwitchTexture", xbox::EMUPATCH(D3DDevice_SwitchTexture), PATCH_HLE_D3D),
 	PATCH_ENTRY("D3DDevice_UpdateOverlay", xbox::EMUPATCH(D3DDevice_UpdateOverlay), PATCH_HLE_D3D),
+	PATCH_ENTRY("D3DDevice_UpdateOverlay_16__LTCG_eax2", xbox::EMUPATCH(D3DDevice_UpdateOverlay_16__LTCG_eax2), PATCH_HLE_D3D),
 	PATCH_ENTRY("D3DResource_BlockUntilNotBusy", xbox::EMUPATCH(D3DResource_BlockUntilNotBusy), PATCH_HLE_D3D),
 	PATCH_ENTRY("D3D_BlockOnTime", xbox::EMUPATCH(D3D_BlockOnTime), PATCH_HLE_D3D),
-	PATCH_ENTRY("D3D_BlockOnTime_4", xbox::EMUPATCH(D3D_BlockOnTime_4), PATCH_HLE_D3D),
+	PATCH_ENTRY("D3D_BlockOnTime_4__LTCG_eax1", xbox::EMUPATCH(D3D_BlockOnTime_4__LTCG_eax1), PATCH_HLE_D3D),
 	PATCH_ENTRY("D3D_CommonSetRenderTarget", xbox::EMUPATCH(D3D_CommonSetRenderTarget), PATCH_HLE_D3D),
     PATCH_ENTRY("D3D_DestroyResource", xbox::EMUPATCH(D3D_DestroyResource), PATCH_HLE_D3D),
-    PATCH_ENTRY("D3D_DestroyResource__LTCG", xbox::EMUPATCH(D3D_DestroyResource__LTCG), PATCH_HLE_D3D),
+	PATCH_ENTRY("D3D_DestroyResource_0__LTCG_edi1", xbox::EMUPATCH(D3D_DestroyResource_0__LTCG_edi1), PATCH_HLE_D3D),
 	PATCH_ENTRY("D3D_LazySetPointParams", xbox::EMUPATCH(D3D_LazySetPointParams), PATCH_HLE_D3D),
 	PATCH_ENTRY("D3D_SetCommonDebugRegisters", xbox::EMUPATCH(D3D_SetCommonDebugRegisters), PATCH_HLE_D3D),
 	PATCH_ENTRY("Direct3D_CreateDevice", xbox::EMUPATCH(Direct3D_CreateDevice), PATCH_HLE_D3D),
-	PATCH_ENTRY("Direct3D_CreateDevice_16__LTCG_eax_BehaviorFlags_ebx_ppReturnedDeviceInterface", xbox::EMUPATCH(Direct3D_CreateDevice_16__LTCG_eax_BehaviorFlags_ebx_ppReturnedDeviceInterface), PATCH_HLE_D3D),
-	PATCH_ENTRY("Direct3D_CreateDevice_16__LTCG_eax_BehaviorFlags_ecx_ppReturnedDeviceInterface", xbox::EMUPATCH(Direct3D_CreateDevice_16__LTCG_eax_BehaviorFlags_ecx_ppReturnedDeviceInterface), PATCH_HLE_D3D),
-	PATCH_ENTRY("Direct3D_CreateDevice_4", xbox::EMUPATCH(Direct3D_CreateDevice_4), PATCH_HLE_D3D),
+	PATCH_ENTRY("Direct3D_CreateDevice_16__LTCG_eax4_ebx6", xbox::EMUPATCH(Direct3D_CreateDevice_16__LTCG_eax4_ebx6), PATCH_HLE_D3D),
+	PATCH_ENTRY("Direct3D_CreateDevice_16__LTCG_eax4_ecx6", xbox::EMUPATCH(Direct3D_CreateDevice_16__LTCG_eax4_ecx6), PATCH_HLE_D3D),
+	PATCH_ENTRY("Direct3D_CreateDevice_4__LTCG_eax1_ecx3", xbox::EMUPATCH(Direct3D_CreateDevice_4__LTCG_eax1_ecx3), PATCH_HLE_D3D),
 	PATCH_ENTRY("Lock2DSurface", xbox::EMUPATCH(Lock2DSurface), PATCH_HLE_D3D),
+	PATCH_ENTRY("Lock2DSurface_16__LTCG_esi4_eax5", xbox::EMUPATCH(Lock2DSurface_16__LTCG_esi4_eax5), PATCH_HLE_D3D),
 	PATCH_ENTRY("Lock3DSurface", xbox::EMUPATCH(Lock3DSurface), PATCH_HLE_D3D),
+	PATCH_ENTRY("Lock3DSurface_16__LTCG_eax4", xbox::EMUPATCH(Lock3DSurface_16__LTCG_eax4), PATCH_HLE_D3D),
 
 	// DSOUND
 	PATCH_ENTRY("CDirectSound3DCalculator_Calculate3D", xbox::EMUPATCH(CDirectSound3DCalculator_Calculate3D), PATCH_HLE_DSOUND),

src/core/kernel/exports/EmuKrnlAv.cpp

@@ -211,6 +211,7 @@ XBSYSAPI EXPORTNUM(2) xbox::void_xt NTAPI xbox::AvSendTVEncoderOption
 		LOG_UNIMPLEMENTED();
 		break;
 	case AV_OPTION_FLICKER_FILTER:
+		// Test case: Is called from AvSetDisplayMode (kernel) and D3DDevice_SetFlickerFilter (D3D8) functions.
 		LOG_UNIMPLEMENTED();
 		break;
 	case AV_OPTION_ZERO_MODE:
@@ -220,6 +221,7 @@ XBSYSAPI EXPORTNUM(2) xbox::void_xt NTAPI xbox::AvSendTVEncoderOption
 		LOG_UNIMPLEMENTED();
 		break;
 	case AV_OPTION_ENABLE_LUMA_FILTER:
+		// Test case: Is called from AvSetDisplayMode (kernel) and D3DDevice_SetSoftDisplayFilter (D3D8) functions.
 		LOG_UNIMPLEMENTED();
 		break;
 	case AV_OPTION_GUESS_FIELD:

src/core/kernel/init/CxbxKrnl.cpp

@@ -514,12 +514,84 @@ static bool CxbxrKrnlXbeSystemSelector(int BootFlags,
 	// Load Xbe (this one will reside above WinMain's virtual_memory_placeholder)
 	std::filesystem::path xbeDirectory = std::filesystem::path(xbePath).parent_path();
 
-#ifdef CHIHIRO_WORK
-	// If the Xbe is Chihiro, and we were not launched by SEGABOOT, we need to load SEGABOOT from the Chihiro Media Board rom instead!
+	CxbxKrnl_Xbe = new Xbe(xbePath.c_str()); // TODO : Instead of using the Xbe class, port Dxbx _ReadXbeBlock()
+
+	if (CxbxKrnl_Xbe->HasFatalError()) {
+		CxbxrAbort(CxbxKrnl_Xbe->GetError().c_str());
+		return false;
+	}
+
+	// Check the signature of the xbe
+	if (CxbxKrnl_Xbe->CheckSignature()) {
+		EmuLogInit(LOG_LEVEL::INFO, "Valid xbe signature. Xbe is legit");
+	}
+	else {
+		EmuLogInit(LOG_LEVEL::WARNING, "Invalid xbe signature. Homebrew, tampered or pirated xbe?");
+	}
+
+	// Check the integrity of the xbe sections
+	for (uint32_t sectionIndex = 0; sectionIndex < CxbxKrnl_Xbe->m_Header.dwSections; sectionIndex++) {
+		if (CxbxKrnl_Xbe->CheckSectionIntegrity(sectionIndex)) {
+			EmuLogInit(LOG_LEVEL::INFO, "SHA hash check of section %s successful", CxbxKrnl_Xbe->m_szSectionName[sectionIndex]);
+		}
+		else {
+			EmuLogInit(LOG_LEVEL::WARNING, "SHA hash of section %s doesn't match, section is corrupted", CxbxKrnl_Xbe->m_szSectionName[sectionIndex]);
+		}
+	}
+
+	// If CLI has given console type, then enforce it.
+	if (cli_config::hasKey(cli_config::system_chihiro)) {
+		EmuLogInit(LOG_LEVEL::INFO, "Auto detect is disabled, running as chihiro.");
+		emulate_system = SYSTEM_CHIHIRO;
+	}
+	else if (cli_config::hasKey(cli_config::system_devkit)) {
+		EmuLogInit(LOG_LEVEL::INFO, "Auto detect is disabled, running as devkit.");
+		emulate_system = SYSTEM_DEVKIT;
+	}
+	else if (cli_config::hasKey(cli_config::system_retail)) {
+		EmuLogInit(LOG_LEVEL::INFO, "Auto detect is disabled, running as retail.");
+		emulate_system = SYSTEM_XBOX;
+	}
+	// Otherwise, use auto detect method.
+	else {
+		// Detect XBE type :
+		XbeType xbeType = CxbxKrnl_Xbe->GetXbeType();
+		EmuLogInit(LOG_LEVEL::INFO, "Auto detect: XbeType = %s", GetXbeTypeToStr(xbeType));
+
+		// Convert XBE type into corresponding system to emulate.
+		switch (xbeType) {
+			case XbeType::xtChihiro:
+				emulate_system = SYSTEM_CHIHIRO;
+				break;
+			case XbeType::xtDebug:
+				emulate_system = SYSTEM_DEVKIT;
+				break;
+			case XbeType::xtRetail:
+				emulate_system = SYSTEM_XBOX;
+				break;
+			DEFAULT_UNREACHABLE;
+		}
+
 		// If the XBE path contains a boot.id, it must be a Chihiro title
 		// This is necessary as some Chihiro games use the Debug xor instead of the Chihiro ones
 		// which means we cannot rely on that alone.
-	if (BootFlags == BOOT_NONE && std::filesystem::exists(xbeDirectory / "boot.id")) {
+		if (std::filesystem::exists(xbeDirectory / "boot.id")) {
+			emulate_system = SYSTEM_CHIHIRO;
+		}
+	}
+
+	EmuLogInit(LOG_LEVEL::INFO, "Host's compatible system types: %2X", reserved_systems);
+	// If the system to emulate isn't supported on host, enforce failure.
+	if (!isSystemFlagSupport(reserved_systems, emulate_system)) {
+		CxbxrAbort("Unable to emulate system type due to host is not able to reserve required memory ranges.");
+		return false;
+	}
+	// Clear emulation system from reserved systems so all unneeded memory ranges can be freed.
+	reserved_systems &= ~emulate_system;
+
+#ifdef CHIHIRO_WORK
+	// If the Xbe is Chihiro, and we were not launched by SEGABOOT, we need to load SEGABOOT from the Chihiro Media Board rom instead!
+	if (BootFlags == BOOT_NONE && emulate_system == SYSTEM_CHIHIRO) {
 
 		std::string chihiroMediaBoardRom = g_DataFilePath + "/EmuDisk/" + MediaBoardRomFile;
 		if (!std::filesystem::exists(chihiroMediaBoardRom)) {
@@ -580,82 +652,9 @@ static bool CxbxrKrnlXbeSystemSelector(int BootFlags,
 		// Launch Segaboot
 		CxbxLaunchNewXbe(chihiroSegaBootNew);
 		CxbxrShutDown(true);
-
 	}
 #endif // Chihiro wip block
 
-	CxbxKrnl_Xbe = new Xbe(xbePath.c_str()); // TODO : Instead of using the Xbe class, port Dxbx _ReadXbeBlock()
-
-	if (CxbxKrnl_Xbe->HasFatalError()) {
-		CxbxrAbort(CxbxKrnl_Xbe->GetError().c_str());
-		return false;
-	}
-
-	// Check the signature of the xbe
-	if (CxbxKrnl_Xbe->CheckSignature()) {
-		EmuLogInit(LOG_LEVEL::INFO, "Valid xbe signature. Xbe is legit");
-	}
-	else {
-		EmuLogInit(LOG_LEVEL::WARNING, "Invalid xbe signature. Homebrew, tampered or pirated xbe?");
-	}
-
-	// Check the integrity of the xbe sections
-	for (uint32_t sectionIndex = 0; sectionIndex < CxbxKrnl_Xbe->m_Header.dwSections; sectionIndex++) {
-		if (CxbxKrnl_Xbe->CheckSectionIntegrity(sectionIndex)) {
-			EmuLogInit(LOG_LEVEL::INFO, "SHA hash check of section %s successful", CxbxKrnl_Xbe->m_szSectionName[sectionIndex]);
-		}
-		else {
-			EmuLogInit(LOG_LEVEL::WARNING, "SHA hash of section %s doesn't match, section is corrupted", CxbxKrnl_Xbe->m_szSectionName[sectionIndex]);
-		}
-	}
-
-	// If CLI has given console type, then enforce it.
-	if (cli_config::hasKey(cli_config::system_chihiro)) {
-		EmuLogInit(LOG_LEVEL::INFO, "Auto detect is disabled, running as chihiro.");
-		emulate_system = SYSTEM_CHIHIRO;
-	}
-	else if (cli_config::hasKey(cli_config::system_devkit)) {
-		EmuLogInit(LOG_LEVEL::INFO, "Auto detect is disabled, running as devkit.");
-		emulate_system = SYSTEM_DEVKIT;
-	}
-	else if (cli_config::hasKey(cli_config::system_retail)) {
-		EmuLogInit(LOG_LEVEL::INFO, "Auto detect is disabled, running as retail.");
-		emulate_system = SYSTEM_XBOX;
-	}
-	// Otherwise, use auto detect method.
-	else {
-		// Detect XBE type :
-		XbeType xbeType = CxbxKrnl_Xbe->GetXbeType();
-		EmuLogInit(LOG_LEVEL::INFO, "Auto detect: XbeType = %s", GetXbeTypeToStr(xbeType));
-
-		// Convert XBE type into corresponding system to emulate.
-		switch (xbeType) {
-			case XbeType::xtChihiro:
-				emulate_system = SYSTEM_CHIHIRO;
-				break;
-			case XbeType::xtDebug:
-				emulate_system = SYSTEM_DEVKIT;
-				break;
-			case XbeType::xtRetail:
-				emulate_system = SYSTEM_XBOX;
-				break;
-			DEFAULT_UNREACHABLE;
-		}
-
-		if (std::filesystem::exists(xbeDirectory / "boot.id")) {
-			emulate_system = SYSTEM_CHIHIRO;
-		}
-	}
-
-	EmuLogInit(LOG_LEVEL::INFO, "Host's compatible system types: %2X", reserved_systems);
-	// If the system to emulate isn't supported on host, enforce failure.
-	if (!isSystemFlagSupport(reserved_systems, emulate_system)) {
-		CxbxrAbort("Unable to emulate system type due to host is not able to reserve required memory ranges.");
-		return false;
-	}
-	// Clear emulation system from reserved systems so all unneeded memory ranges can be freed.
-	reserved_systems &= ~emulate_system;
-
 	// Once we have determine which system type to run as, enforce it in future reboots.
 	if ((BootFlags & BOOT_QUICK_REBOOT) == 0) {
 		const char* system_str = GetSystemTypeToStr(emulate_system);

src/core/kernel/support/NativeHandle.cpp

@@ -26,6 +26,7 @@
 // ******************************************************************
 
 #include <core\kernel\exports\xboxkrnl.h>
+#include <chrono>
 #include <unordered_map>
 #include <shared_mutex>
 #include "Windows.h"

src/gui/WndMain.cpp

@@ -56,6 +56,8 @@
 #undef GetSystemMetrics // Force remove DirectX 8's multimon.h defined function (redirect to xGetSystemMetrics).
 #include <WinUser.h> // For GetSystemMetrics
 
+#include <dwmapi.h> // For DwmSetWindowAttribute
+
 #include <io.h>
 #include <shlobj.h>
 
@@ -68,6 +70,9 @@
 
 #define XBOX_LED_FLASH_PERIOD 176 // if you know a more accurate value, put it here
 
+static const char* popup_force_blank_console_type = "By force using the %s console type may cause side effects and may not be used to report to the game compatibility website.";
+static const char* popup_will_not_take_effect_until_the_next_emulation = "This will not take effect until the next time emulation is started.";
+
 static int gameLogoWidth, gameLogoHeight;
 static int splashLogoWidth, splashLogoHeight;
 
@@ -323,6 +328,10 @@ LRESULT CALLBACK WndMain::WndProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lP
 			ChangeWindowMessageFilterEx(hwnd, WM_COPYDATA, MSGFLT_ALLOW, nullptr);
 			ChangeWindowMessageFilterEx(hwnd, 0x0049, MSGFLT_ALLOW, nullptr);
 
+			// Remove rounded corners from the render window on Windows 11
+			const DWM_WINDOW_CORNER_PREFERENCE corner_preference = DWMWCP_DONOTROUND;
+			DwmSetWindowAttribute(hwnd, DWMWA_WINDOW_CORNER_PREFERENCE, &corner_preference, sizeof(corner_preference));
+
             m_bCreated = true;
         }
         break;
@@ -972,6 +981,49 @@ LRESULT CALLBACK WndMain::WndProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lP
 			}
 			break;
 
+			case ID_SETTINGS_CONFIG_CONT_AUTO:
+			{
+				g_Settings->m_gui.ConsoleTypeToggle = EMU_CONSOLE_TYPE_AUTO;
+				if (m_bIsStarted) {
+					PopupInfo(m_hwnd, popup_will_not_take_effect_until_the_next_emulation);
+				}
+				RefreshMenus();
+			}
+			break;
+
+			case ID_SETTINGS_CONFIG_CONT_RETAIL:
+			{
+				g_Settings->m_gui.ConsoleTypeToggle = EMU_CONSOLE_TYPE_RETAIL;
+				PopupWarning(m_hwnd, popup_force_blank_console_type, "retail");
+				if (m_bIsStarted) {
+					PopupInfo(m_hwnd, popup_will_not_take_effect_until_the_next_emulation);
+				}
+				RefreshMenus();
+			}
+			break;
+
+			case ID_SETTINGS_CONFIG_CONT_DEVKIT:
+			{
+				g_Settings->m_gui.ConsoleTypeToggle = EMU_CONSOLE_TYPE_DEVKIT;
+				PopupWarning(m_hwnd, popup_force_blank_console_type, "devkit");
+				if (m_bIsStarted) {
+					PopupInfo(m_hwnd, popup_will_not_take_effect_until_the_next_emulation);
+				}
+				RefreshMenus();
+			}
+			break;
+
+			case ID_SETTINGS_CONFIG_CONT_CHIHIRO:
+			{
+				g_Settings->m_gui.ConsoleTypeToggle = EMU_CONSOLE_TYPE_CHIHIRO;
+				PopupWarning(m_hwnd, popup_force_blank_console_type, "chihiro");
+				if (m_bIsStarted) {
+					PopupInfo(m_hwnd, popup_will_not_take_effect_until_the_next_emulation);
+				}
+				RefreshMenus();
+			}
+			break;
+
 			case ID_SETTINGS_CONFIG_DLOCCUSTOM:
 			{
 				char szDir[MAX_PATH];
@@ -1099,7 +1151,7 @@ LRESULT CALLBACK WndMain::WndProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lP
 				else {
 					g_Settings->m_core.KrnlDebugMode = DM_NONE;
 				}
-				PopupInfo(m_hwnd, "This will not take effect until the next time emulation is started.");
+				PopupInfo(m_hwnd, popup_will_not_take_effect_until_the_next_emulation);
 
 				RefreshMenus();
 
@@ -1706,6 +1758,36 @@ void WndMain::RefreshMenus()
 			chk_flag = (g_Settings->m_hacks.SkipRdtscPatching) ? MF_CHECKED : MF_UNCHECKED;
 			CheckMenuItem(settings_menu, ID_HACKS_SKIPRDTSCPATCHING, chk_flag);
 
+			switch (g_Settings->m_gui.ConsoleTypeToggle) {
+				case EMU_CONSOLE_TYPE_AUTO:
+					CheckMenuItem(settings_menu, ID_SETTINGS_CONFIG_CONT_AUTO, MF_CHECKED);
+					CheckMenuItem(settings_menu, ID_SETTINGS_CONFIG_CONT_RETAIL, MF_UNCHECKED);
+					CheckMenuItem(settings_menu, ID_SETTINGS_CONFIG_CONT_DEVKIT, MF_UNCHECKED);
+					CheckMenuItem(settings_menu, ID_SETTINGS_CONFIG_CONT_CHIHIRO, MF_UNCHECKED);
+					break;
+
+				case EMU_CONSOLE_TYPE_RETAIL:
+					CheckMenuItem(settings_menu, ID_SETTINGS_CONFIG_CONT_AUTO, MF_UNCHECKED);
+					CheckMenuItem(settings_menu, ID_SETTINGS_CONFIG_CONT_RETAIL, MF_CHECKED);
+					CheckMenuItem(settings_menu, ID_SETTINGS_CONFIG_CONT_DEVKIT, MF_UNCHECKED);
+					CheckMenuItem(settings_menu, ID_SETTINGS_CONFIG_CONT_CHIHIRO, MF_UNCHECKED);
+					break;
+
+				case EMU_CONSOLE_TYPE_DEVKIT:
+					CheckMenuItem(settings_menu, ID_SETTINGS_CONFIG_CONT_AUTO, MF_UNCHECKED);
+					CheckMenuItem(settings_menu, ID_SETTINGS_CONFIG_CONT_RETAIL, MF_UNCHECKED);
+					CheckMenuItem(settings_menu, ID_SETTINGS_CONFIG_CONT_DEVKIT, MF_CHECKED);
+					CheckMenuItem(settings_menu, ID_SETTINGS_CONFIG_CONT_CHIHIRO, MF_UNCHECKED);
+					break;
+
+				case EMU_CONSOLE_TYPE_CHIHIRO:
+					CheckMenuItem(settings_menu, ID_SETTINGS_CONFIG_CONT_AUTO, MF_UNCHECKED);
+					CheckMenuItem(settings_menu, ID_SETTINGS_CONFIG_CONT_RETAIL, MF_UNCHECKED);
+					CheckMenuItem(settings_menu, ID_SETTINGS_CONFIG_CONT_DEVKIT, MF_UNCHECKED);
+					CheckMenuItem(settings_menu, ID_SETTINGS_CONFIG_CONT_CHIHIRO, MF_CHECKED);
+					break;
+			}
+
 			switch (g_Settings->m_gui.DataStorageToggle) {
 				case CXBX_DATA_APPDATA:
 					CheckMenuItem(settings_menu, ID_SETTINGS_CONFIG_DLOCAPPDATA, MF_CHECKED);
@@ -2244,6 +2326,20 @@ void WndMain::StartEmulation(HWND hwndParent, DebuggerState LocalDebuggerState /
         cli_config::SetLoad(m_XbeFilename);
         cli_config::SetValue(cli_config::hwnd, hwndParent);
         cli_config::SetValue(cli_config::debug_mode, g_Settings->m_core.KrnlDebugMode);
+        cli_config::ClearSystemType(); // Require to reset system type in GUI in order to choose the new system option.
+        if (g_Settings->m_gui.ConsoleTypeToggle > 0) {
+            switch (g_Settings->m_gui.ConsoleTypeToggle) {
+                case EMU_CONSOLE_TYPE_RETAIL:
+                    cli_config::SetSystemType(cli_config::system_retail);
+                    break;
+                case EMU_CONSOLE_TYPE_DEVKIT:
+                    cli_config::SetSystemType(cli_config::system_devkit);
+                    break;
+                case EMU_CONSOLE_TYPE_CHIHIRO:
+                    cli_config::SetSystemType(cli_config::system_chihiro);
+                    break;
+            }
+        }
         if (g_Settings->m_core.KrnlDebugMode == DM_FILE) {
             cli_config::SetValue(cli_config::debug_file, g_Settings->m_core.szKrnlDebug);
         }

src/gui/input/DlgLibusbControllerConfig.cpp

@@ -31,6 +31,7 @@
 #include "gui\resource\ResCxbx.h"
 #include "input\InputWindow.h"
 #include "common\input\LibusbDevice.h"
+#include <chrono>
 
 
 static LibusbInputWindow *g_InputWindow = nullptr;

src/gui/resource/Cxbx.rc

@@ -763,6 +763,13 @@ BEGIN
         MENUITEM "Config &Network...",          ID_SETTINGS_CONFIG_NETWORK,MFT_STRING,MFS_ENABLED
         MENUITEM "Config &Eeprom...",           ID_SETTINGS_CONFIG_EEPROM,MFT_STRING,MFS_ENABLED
         MENUITEM "Config &Logging...",          ID_SETTINGS_CONFIG_LOGGING,MFT_STRING,MFS_ENABLED
+        POPUP "Config &Console Type..."
+        BEGIN
+            MENUITEM "&Auto",                       ID_SETTINGS_CONFIG_CONT_AUTO
+            MENUITEM "&Retail",                     ID_SETTINGS_CONFIG_CONT_RETAIL
+            MENUITEM "&Devkit",                     ID_SETTINGS_CONFIG_CONT_DEVKIT
+            MENUITEM "&Chihiro",                    ID_SETTINGS_CONFIG_CONT_CHIHIRO
+        END
         POPUP "Config &Data Location...",       65535,MFT_STRING,MFS_ENABLED
         BEGIN
             MENUITEM "Store in AppData",            ID_SETTINGS_CONFIG_DLOCAPPDATA,MFT_STRING,MFS_ENABLED

src/gui/resource/ResCxbx.h

@@ -354,6 +354,10 @@
 #define ID_SETTINGS_IGNOREINVALIDXBESIG 40114
 #define ID_SETTINGS_IGNOREINVALIDXBESEC 40115
 #define ID_SYNC_TIME_CHANGE             40116
+#define ID_SETTINGS_CONFIG_CONT_AUTO    40117
+#define ID_SETTINGS_CONFIG_CONT_RETAIL  40118
+#define ID_SETTINGS_CONFIG_CONT_DEVKIT  40119
+#define ID_SETTINGS_CONFIG_CONT_CHIHIRO 40120
 #define IDC_STATIC                      -1
 
 // Next default values for new objects
@@ -361,7 +365,7 @@
 #ifdef APSTUDIO_INVOKED
 #ifndef APSTUDIO_READONLY_SYMBOLS
 #define _APS_NEXT_RESOURCE_VALUE        139
-#define _APS_NEXT_COMMAND_VALUE         40117
+#define _APS_NEXT_COMMAND_VALUE         40121
 #define _APS_NEXT_CONTROL_VALUE         1308
 #define _APS_NEXT_SYMED_VALUE           109
 #endif