.github/workflows/CI.yml

@@ -22,20 +22,23 @@ on:
 
 jobs:
   build-windows:
-    name: Build (Windows, ${{ matrix.configuration }}) # runner.os doesn't work here
+    name: Build (Windows, ${{ matrix.configuration }}, VS${{ matrix.vsver }}) # runner.os doesn't work here
-    runs-on: windows-2025
+    runs-on: windows-${{ matrix.vsver }}
     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 -DBUILD_CXBXR_DEBUGGER=ON -DCMAKE_SYSTEM_VERSION=7
+        run: cmake -B build -A Win32,version=${{ matrix.sdkver }} -DCMAKE_SYSTEM_VERSION=${{ matrix.winver }}
       - name: Build
         run: cmake --build build --config ${{ matrix.configuration }} -j $env:NUMBER_OF_PROCESSORS
       - name: Prepare artifacts
@@ -44,7 +47,7 @@ jobs:
       - uses: actions/upload-artifact@v4
         if: matrix.configuration == 'Release'
         with:
-          name: CxbxReloaded-${{ matrix.configuration }}
+          name: CxbxReloaded-${{ matrix.configuration }}-VS${{ matrix.vsver }}
           path: artifacts/bin
           if-no-files-found: error
 

CMakeLists.txt

@@ -1,4 +1,4 @@
-cmake_minimum_required (VERSION 3.12)
+cmake_minimum_required (VERSION 3.8)
 
 project(Cxbx-Reloaded)
 
@@ -430,12 +430,6 @@ 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")
@@ -460,7 +454,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])" AND BUILD_CXBXR_DEBUGGER)
+if(${CMAKE_GENERATOR} MATCHES "Visual Studio ([^9]|[9][0-9])")
  # 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,7 +89,6 @@ 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)
@@ -97,11 +96,10 @@ 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 the following command: `cmake -B build -G "Visual Studio 17 2022" -A Win32` \
+3. Run these commands.
-   **NOTES**:
+    1. `mkdir build & cd build`
-     * VS2022 17.0 or later is required.
+    2. `cmake .. -G "Visual Studio 17 2022" -A Win32`
-     * To build the Cxbx-Reloaded Debugger tool, add the variable `-DBUILD_CXBXR_DEBUGGER=ON` to the above command.
+        * VS2022 17.0 or later is required.
-       * _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 fa24d868ac2f8fd558e4e914c9863411245db8fd
+Subproject commit b424665e0899769b200231ba943353a5fee1b6b6

import/XbSymbolDatabase

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

projects/cxbx/CMakeLists.txt

@@ -189,7 +189,7 @@ install(TARGETS ${PROJECT_NAME}
   RUNTIME DESTINATION bin
 )
 
-if(${CMAKE_GENERATOR} MATCHES "Visual Studio ([^9]|[9][0-9])" AND BUILD_CXBXR_DEBUGGER)
+if(${CMAKE_GENERATOR} MATCHES "Visual Studio ([^9]|[9][0-9])")
   add_dependencies(cxbx cxbxr-debugger)
 endif()
 

projects/imgui/CMakeLists.txt

@@ -1,4 +1,4 @@
-cmake_minimum_required (VERSION 3.12)
+cmake_minimum_required (VERSION 3.8)
 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.12)
+cmake_minimum_required (VERSION 3.8)
 project(libtomcrypt)
 
 # Suppress extra stuff from generated solution

projects/libtom/math/CMakeLists.txt

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

projects/libusb/CMakeLists.txt

@@ -1,4 +1,4 @@
-cmake_minimum_required (VERSION 3.12)
+cmake_minimum_required (VERSION 3.8)
 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.12)
+cmake_minimum_required (VERSION 3.8)
 project(cxbxr-debugger LANGUAGES CSharp)
 
 # Output all binary files into one folder

src/CxbxDebugger/CxbxDebuggerMain.Designer.cs

@@ -41,7 +41,6 @@
             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();
@@ -133,29 +132,18 @@
             // 
             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, 61);
+            this.statusStrip1.Size = new System.Drawing.Size(734, 22);
             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(723, 15);
+            this.lblStatus.Size = new System.Drawing.Size(39, 17);
             this.lblStatus.Text = "Ready";
             // 
             // CxbxDebuggerMain
@@ -192,7 +180,6 @@
         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,7 +90,6 @@ 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";
@@ -343,8 +342,6 @@ 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 ==========
@@ -591,8 +588,6 @@ 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,14 +46,6 @@ 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,
@@ -99,7 +91,6 @@ public:
 		std::string szCustomLocation = "";
 		bool bIgnoreInvalidXbeSig;
 		bool bIgnoreInvalidXbeSec;
-		unsigned int ConsoleTypeToggle;
 	} m_gui;
 
 	// Core settings

src/common/Timer.cpp

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

src/common/input/InputWindow.cpp

@@ -33,7 +33,6 @@
 #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,15 +60,6 @@ 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)
 {
@@ -188,12 +179,4 @@ 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,6 +57,5 @@ 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,50 +4280,3 @@ 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_eax4_ebx6)
+xbox::hresult_xt WINAPI EMUPATCH(Direct3D_CreateDevice_16__LTCG_eax_BehaviorFlags_ebx_ppReturnedDeviceInterface)
 (
     uint_xt                        Adapter,
     D3DDEVTYPE                  DeviceType,
@@ -84,7 +84,7 @@ xbox::hresult_xt WINAPI EMUPATCH(Direct3D_CreateDevice_16__LTCG_eax4_ebx6)
     X_D3DPRESENT_PARAMETERS    *pPresentationParameters
 );
 
-xbox::hresult_xt WINAPI EMUPATCH(Direct3D_CreateDevice_16__LTCG_eax4_ecx6)
+xbox::hresult_xt WINAPI EMUPATCH(Direct3D_CreateDevice_16__LTCG_eax_BehaviorFlags_ecx_ppReturnedDeviceInterface)
 (
     uint_xt                        Adapter,
     D3DDEVTYPE                  DeviceType,
@@ -92,7 +92,7 @@ xbox::hresult_xt WINAPI EMUPATCH(Direct3D_CreateDevice_16__LTCG_eax4_ecx6)
     X_D3DPRESENT_PARAMETERS    *pPresentationParameters
 );
 
-xbox::hresult_xt WINAPI EMUPATCH(Direct3D_CreateDevice_4__LTCG_eax1_ecx3)
+xbox::hresult_xt WINAPI EMUPATCH(Direct3D_CreateDevice_4)
 (
     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__LTCG_eax1)();
+xbox::hresult_xt WINAPI EMUPATCH(D3DDevice_EndVisibilityTest_0)();
 
 // ******************************************************************
 // * 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_ecx1_eax2)();
+xbox::void_xt WINAPI EMUPATCH(D3DDevice_LoadVertexShader_0__LTCG_eax_Address_ecx_Handle)();
-xbox::void_xt WINAPI EMUPATCH(D3DDevice_LoadVertexShader_0__LTCG_edx1_eax2)();
+xbox::void_xt WINAPI EMUPATCH(D3DDevice_LoadVertexShader_0__LTCG_eax_Address_edx_Handle)();
-xbox::void_xt WINAPI EMUPATCH(D3DDevice_LoadVertexShader_4__LTCG_eax1)
+xbox::void_xt WINAPI EMUPATCH(D3DDevice_LoadVertexShader_4)
 (
     dword_xt                       Address
 );
@@ -309,18 +309,9 @@ X_D3DSurface* WINAPI EMUPATCH(D3DDevice_GetBackBuffer2_0__LTCG_eax1)();
 // ******************************************************************
 xbox::void_xt WINAPI EMUPATCH(D3DDevice_GetBackBuffer)
 (
-    int_xt             BackBuffer,
+    int_xt                 BackBuffer,
-    D3DBACKBUFFER_TYPE Type,
+    D3DBACKBUFFER_TYPE  Type,
-    X_D3DSurface     **ppBackBuffer
+    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
 );
 
 // ******************************************************************
@@ -437,7 +428,7 @@ xbox::void_xt WINAPI EMUPATCH(D3DDevice_SetVertexShaderConstant)
     dword_xt       ConstantCount
 );
 
-xbox::void_xt __fastcall EMUPATCH(D3DDevice_SetVertexShaderConstant_8__LTCG_edx3)
+xbox::void_xt __fastcall EMUPATCH(D3DDevice_SetVertexShaderConstant_8)
 (
     void*,
     dword_xt    ConstantCount,
@@ -483,11 +474,6 @@ 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
 // ******************************************************************
@@ -523,7 +509,7 @@ xbox::void_xt WINAPI EMUPATCH(D3DDevice_SetPixelShader)
     dword_xt           Handle
 );
 
-xbox::void_xt WINAPI EMUPATCH(D3DDevice_SetPixelShader_0__LTCG_eax1)();
+xbox::void_xt WINAPI EMUPATCH(D3DDevice_SetPixelShader_0__LTCG_eax_handle)();
 
 // ******************************************************************
 // * patch: D3DDevice_CreateTexture2
@@ -608,9 +594,9 @@ xbox::void_xt WINAPI EMUPATCH(D3DDevice_SetIndices)
 );
 
 // ******************************************************************
-// * patch: D3DDevice_SetIndices_4__LTCG_ebx1
+// * patch: D3DDevice_SetIndices_4
 // ******************************************************************
-xbox::void_xt WINAPI EMUPATCH(D3DDevice_SetIndices_4__LTCG_ebx1)
+xbox::void_xt WINAPI EMUPATCH(D3DDevice_SetIndices_4)
 (
     uint_xt                BaseVertexIndex
 );
@@ -624,12 +610,12 @@ xbox::void_xt WINAPI EMUPATCH(D3DDevice_SetTexture)
 	X_D3DBaseTexture  *pTexture
 );
 
-xbox::void_xt WINAPI EMUPATCH(D3DDevice_SetTexture_4__LTCG_eax2)
+xbox::void_xt WINAPI EMUPATCH(D3DDevice_SetTexture_4__LTCG_eax_pTexture)
 (
 	dword_xt           Stage
 );
 
-xbox::void_xt WINAPI EMUPATCH(D3DDevice_SetTexture_4__LTCG_eax1)
+xbox::void_xt WINAPI EMUPATCH(D3DDevice_SetTexture_4__LTCG_eax_Stage)
 (
 	X_D3DBaseTexture  *pTexture
 );
@@ -693,9 +679,9 @@ xbox::void_xt WINAPI EMUPATCH(D3DDevice_SetVertexData4f)
 );
 
 // ******************************************************************
-// * patch: D3DDevice_SetVertexData4f_16__LTCG_edi1
+// * patch: D3DDevice_SetVertexData4f_16
 // ******************************************************************
-xbox::void_xt WINAPI EMUPATCH(D3DDevice_SetVertexData4f_16__LTCG_edi1)
+xbox::void_xt WINAPI EMUPATCH(D3DDevice_SetVertexData4f_16)
 (
 	float_xt   a,
 	float_xt   b,
@@ -750,14 +736,6 @@ 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
 // ******************************************************************
@@ -790,7 +768,7 @@ dword_xt WINAPI EMUPATCH(D3DDevice_Swap)
     dword_xt Flags
 );
 
-dword_xt WINAPI EMUPATCH(D3DDevice_Swap_0__LTCG_eax1)();
+dword_xt WINAPI EMUPATCH(D3DDevice_Swap_0)();
 
 // ******************************************************************
 // * patch: IDirect3DResource8_Register
@@ -842,21 +820,10 @@ xbox::void_xt WINAPI EMUPATCH(Lock2DSurface)
 (
     X_D3DPixelContainer *pPixelContainer,
     D3DCUBEMAP_FACES     FaceType,
-    uint_xt              Level,
+    uint_xt                 Level,
     D3DLOCKED_RECT      *pLockedRect,
     RECT                *pRect,
-    dword_xt             Flags
+    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
 );
 
 // ******************************************************************
@@ -865,21 +832,10 @@ xbox::void_xt WINAPI EMUPATCH(Lock2DSurface_16__LTCG_esi4_eax5)
 xbox::void_xt WINAPI EMUPATCH(Lock3DSurface)
 (
     X_D3DPixelContainer *pPixelContainer,
-    uint_xt              Level,
+    uint_xt				Level,
-    D3DLOCKED_BOX       *pLockedVolume,
+	D3DLOCKED_BOX		*pLockedVolume,
-    D3DBOX              *pBox,
+	D3DBOX				*pBox,
-    dword_xt             Flags
+	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
@@ -1008,11 +964,6 @@ 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
 // ******************************************************************
@@ -1021,18 +972,7 @@ xbox::void_xt WINAPI EMUPATCH(D3DDevice_UpdateOverlay)
     X_D3DSurface *pSurface,
     CONST RECT   *SrcRect,
     CONST RECT   *DstRect,
-    bool_xt       EnableColorKey,
+    bool_xt          EnableColorKey,
-    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
 );
 
@@ -1368,11 +1308,6 @@ 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
 // ******************************************************************
@@ -1422,20 +1357,20 @@ xbox::void_xt WINAPI EMUPATCH(D3DDevice_SetStreamSource)
     uint_xt                Stride
 );
 
-xbox::void_xt WINAPI EMUPATCH(D3DDevice_SetStreamSource_0__LTCG_eax1_edi2_ebx3)();
+xbox::void_xt WINAPI EMUPATCH(D3DDevice_SetStreamSource_0__LTCG_eax_StreamNumber_edi_pStreamData_ebx_Stride)();
 
-xbox::void_xt WINAPI EMUPATCH(D3DDevice_SetStreamSource_4__LTCG_eax1_ebx2)
+xbox::void_xt WINAPI EMUPATCH(D3DDevice_SetStreamSource_4)
 (
     uint_xt                Stride
 );
 
-xbox::void_xt WINAPI EMUPATCH(D3DDevice_SetStreamSource_8__LTCG_eax1)
+xbox::void_xt WINAPI EMUPATCH(D3DDevice_SetStreamSource_8)
 (
     X_D3DVertexBuffer  *pStreamData,
     uint_xt                Stride
 );
 
-xbox::void_xt __fastcall EMUPATCH(D3DDevice_SetStreamSource_8__LTCG_edx1)
+xbox::void_xt __fastcall EMUPATCH(D3DDevice_SetStreamSource_8__LTCG_edx_StreamNumber)
 (
     void*,
     uint_xt                StreamNumber,
@@ -1451,7 +1386,7 @@ xbox::void_xt WINAPI EMUPATCH(D3DDevice_SetVertexShader)
     dword_xt            Handle
 );
 
-xbox::void_xt WINAPI EMUPATCH(D3DDevice_SetVertexShader_0__LTCG_ebx1)();
+xbox::void_xt WINAPI EMUPATCH(D3DDevice_SetVertexShader_0)();
 
 // ******************************************************************
 // * patch: D3DDevice_DrawVertices
@@ -1556,14 +1491,6 @@ 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
 // ******************************************************************
@@ -1596,9 +1523,9 @@ xbox::void_xt WINAPI EMUPATCH(D3DDevice_SetRenderTarget)
 );
 
 // ******************************************************************
-// * patch: D3DDevice_SetRenderTarget_0__LTCG_ecx1_eax2
+// * patch: D3DDevice_SetRenderTarget_0
 // ******************************************************************
-xbox::void_xt WINAPI EMUPATCH(D3DDevice_SetRenderTarget_0__LTCG_ecx1_eax2)();
+xbox::void_xt WINAPI EMUPATCH(D3DDevice_SetRenderTarget_0)();
 
 // ******************************************************************
 // * patch: D3D_CommonSetRenderTarget
@@ -1619,7 +1546,7 @@ xbox::void_xt WINAPI EMUPATCH(D3DDevice_SetPalette)
     X_D3DPalette *pPalette
 );
 
-xbox::void_xt WINAPI EMUPATCH(D3DDevice_SetPalette_4__LTCG_eax1)
+xbox::void_xt WINAPI EMUPATCH(D3DDevice_SetPalette_4)
 (
     X_D3DPalette *pPalette
 );
@@ -1632,7 +1559,7 @@ xbox::void_xt WINAPI EMUPATCH(D3DDevice_SetFlickerFilter)
     dword_xt         Filter
 );
 
-xbox::void_xt WINAPI EMUPATCH(D3DDevice_SetFlickerFilter_0__LTCG_esi1)();
+xbox::void_xt WINAPI EMUPATCH(D3DDevice_SetFlickerFilter_0)();
 
 // ******************************************************************
 // * patch: D3DDevice_SetSoftDisplayFilter
@@ -1678,7 +1605,7 @@ xbox::void_xt WINAPI EMUPATCH(D3DDevice_DeleteVertexShader)
     dword_xt Handle
 );
 
-xbox::void_xt WINAPI EMUPATCH(D3DDevice_DeleteVertexShader_0__LTCG_eax1)();
+xbox::void_xt WINAPI EMUPATCH(D3DDevice_DeleteVertexShader_0)();
 
 // ******************************************************************
 // * patch: D3DDevice_GetShaderConstantMode
@@ -1735,14 +1662,6 @@ 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
 // ******************************************************************
@@ -2144,12 +2063,13 @@ void WINAPI EMUPATCH(D3D_SetCommonDebugRegisters)();
 // ******************************************************************
 // * patch: D3D_BlockOnTime
 // ******************************************************************
-void WINAPI EMUPATCH(D3D_BlockOnTime)(dword_xt Time, int MakeSpace);
+void WINAPI EMUPATCH(D3D_BlockOnTime)( dword_xt Unknown1, int Unknown2 );
 
 // ******************************************************************
-// * patch: D3D_BlockOnTime_4__LTCG_eax1
+// * patch: D3D_BlockOnTime_4
+//   One of the parameters (unknown which) passed in EAX
 // ******************************************************************
-void WINAPI EMUPATCH(D3D_BlockOnTime_4__LTCG_eax1)(int MakeSpace);
+void WINAPI EMUPATCH(D3D_BlockOnTime_4)( dword_xt Unknown1 );
 
 // ******************************************************************
 // * patch: D3D_BlockOnResource
@@ -2162,9 +2082,9 @@ void WINAPI EMUPATCH(D3D_BlockOnResource)( X_D3DResource* pResource );
 void WINAPI EMUPATCH(D3D_DestroyResource)( X_D3DResource* pResource );
 
 // ******************************************************************
-// * patch: D3D_DestroyResource_0__LTCG_edi1
+// * patch: D3D_DestroyResource__LTCG
 // ******************************************************************
-void WINAPI EMUPATCH(D3D_DestroyResource_0__LTCG_edi1)();
+void WINAPI EMUPATCH(D3D_DestroyResource__LTCG)();
 
 
 // ******************************************************************

src/core/hle/D3D8/XbVertexShader.cpp

@@ -52,8 +52,6 @@
 #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
@@ -1627,44 +1625,3 @@ 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,6 +252,5 @@ 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,12 +208,8 @@ void CDECL EmuRegisterSymbol(const char* library_str,
                              uint32_t library_flag,
                              uint32_t xref_index,
                              const char* symbol_str,
-                             xbaddr symbol_addr,
+                             uint32_t func_addr,
-                             uint32_t build_version,
+                             uint32_t revision)
-                             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];
@@ -222,8 +218,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 << symbol_addr
+    output << "Symbol: 0x" << std::setfill('0') << std::setw(8) << std::hex << func_addr
-        << " -> " << symbol_str << " " << std::dec << build_version;
+        << " -> " << symbol_str << " " << std::dec << revision;
 
 #if 0 // TODO: XbSymbolDatabase - Need to create a structure for patch and stuff.
     bool IsXRef = OovpaTable->Oovpa->XRefSaveIndex != XRefNoSaveIndex;
@@ -290,7 +286,7 @@ void CDECL EmuRegisterSymbol(const char* library_str,
 
 	output << "\n";
 
-	g_SymbolAddresses[symbol_str] = symbol_addr;
+	g_SymbolAddresses[symbol_str] = func_addr;
     printf(output.str().c_str());
 }
 
@@ -301,22 +297,22 @@ void EmuUpdateLLEStatus(uint32_t XbLibScan)
     g_EmuShared->GetFlagsLLE(&FlagsLLE);
 
     if ((FlagsLLE & LLE_GPU) == false
-        && !((XbLibScan & XBSDBLIB_D3D8) > 0
+        && !((XbLibScan & XbSymbolLib_D3D8) > 0
-            || (XbLibScan & XBSDBLIB_D3D8LTCG) > 0)) {
+            || (XbLibScan & XbSymbolLib_D3D8LTCG) > 0)) {
         bLLE_GPU = true;
         FlagsLLE ^= LLE_GPU;
         EmuOutputMessage(XB_OUTPUT_MESSAGE_INFO, "Fallback to LLE GPU.");
     }
 
     if ((FlagsLLE & LLE_APU) == false
-        && (XbLibScan & XBSDBLIB_DSOUND) == 0) {
+        && (XbLibScan & XbSymbolLib_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 & XBSDBLIB_XAPILIB) == 0) {
+		&& (XbLibScan & XbSymbolLib_XAPILIB) == 0) {
 		bLLE_USB = true;
 		FlagsLLE ^= LLE_USB;
 		EmuOutputMessage(XB_OUTPUT_MESSAGE_INFO, "Fallback to LLE USB.");
@@ -350,16 +346,16 @@ void EmuHLEIntercept(Xbe::Header *pXbeHeader)
 			if (xdkVersion < BuildVersion) {
 				xdkVersion = BuildVersion;
 			}
-			XbLibFlag = XbSDB_LibraryToFlag(std::string(pLibraryVersion[v].szName, pLibraryVersion[v].szName + 8).c_str());
+			XbLibFlag = XbSymbolDatabase_LibraryToFlag(std::string(pLibraryVersion[v].szName, pLibraryVersion[v].szName + 8).c_str());
 			XbLibScan |= XbLibFlag;
 
 			// Keep certain library versions for plugin usage.
-			if ((XbLibFlag & (XBSDBLIB_D3D8 | XBSDBLIB_D3D8LTCG)) > 0) {
+			if ((XbLibFlag & (XbSymbolLib_D3D8 | XbSymbolLib_D3D8LTCG)) > 0) {
 				if (g_LibVersion_D3D8 < BuildVersion) {
 					g_LibVersion_D3D8 = BuildVersion;
 				}
 			}
-			else if ((XbLibFlag & XBSDBLIB_DSOUND) > 0) {
+			else if ((XbLibFlag & XbSymbolLib_DSOUND) > 0) {
 				g_LibVersion_DSOUND = BuildVersion;
 			}
 		}
@@ -367,8 +363,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) {
+			if (strncmp(SectionName, Lib_DSOUND, 8) == 0) {
-				XbLibScan |= XBSDBLIB_DSOUND;
+				XbLibScan |= XbSymbolLib_DSOUND;
 
 				// If DSOUND version is not set, we need to force set it.
 				if (g_LibVersion_DSOUND == 0) {
@@ -421,7 +417,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 == XbSDB_LibraryVersion()) {
+		if (SymbolDatabaseVersionHash == XbSymbolDatabase_LibraryVersion()) {
 			g_SymbolCacheUsed = true;
 			CSimpleIniA::TNamesDepend symbol_names;
 
@@ -492,9 +488,9 @@ void EmuHLEIntercept(Xbe::Header *pXbeHeader)
         }
 #endif
 
-        XbSDB_SetOutputMessage(EmuOutputMessage);
+		XbSymbolDatabase_SetOutputMessage(EmuOutputMessage);
 
-        XbSDB_Scan(pXbeHeader, EmuRegisterSymbol, false);
+		XbSymbolScan(pXbeHeader, EmuRegisterSymbol, false);
 	}
 
 	std::printf("\n");
@@ -503,7 +499,7 @@ void EmuHLEIntercept(Xbe::Header *pXbeHeader)
 	symbolCacheData.Reset();
 
 	// Store Symbol Database version
-	symbolCacheData.SetLongValue(section_info, sect_info_keys.SymbolDatabaseVersionHash, XbSDB_LibraryVersion(), nullptr, /*UseHex =*/false);
+	symbolCacheData.SetLongValue(section_info, sect_info_keys.SymbolDatabaseVersionHash, XbSymbolDatabase_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 = (DWORD*)GetXboxSymbolPointer("JVS_g_pPINSA");
+	g_pPINSA = nullptr;
-	g_pPINSB = (DWORD*)GetXboxSymbolPointer("JVS_g_pPINSB");
+	g_pPINSB = nullptr;
 
 	auto JvsSendCommandOffset1 = (uintptr_t)GetXboxSymbolPointer("JVS_SendCommand");
 	auto JvsSendCommandOffset2 = (uintptr_t)GetXboxSymbolPointer("JVS_SendCommand2");
@@ -218,14 +218,26 @@ 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__LTCG_eax1", xbox::EMUPATCH(D3DDevice_DeleteVertexShader_0__LTCG_eax1), PATCH_HLE_D3D),
+	PATCH_ENTRY("D3DDevice_DeleteVertexShader_0", xbox::EMUPATCH(D3DDevice_DeleteVertexShader_0), 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,14 +83,12 @@ 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__LTCG_eax1", xbox::EMUPATCH(D3DDevice_EndVisibilityTest_0__LTCG_eax1), PATCH_HLE_D3D),
+	PATCH_ENTRY("D3DDevice_EndVisibilityTest_0", xbox::EMUPATCH(D3DDevice_EndVisibilityTest_0), 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),
@@ -109,21 +107,18 @@ 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_ecx1_eax2", xbox::EMUPATCH(D3DDevice_LoadVertexShader_0__LTCG_ecx1_eax2), 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_edx1_eax2", xbox::EMUPATCH(D3DDevice_LoadVertexShader_0__LTCG_edx1_eax2), 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__LTCG_eax1", xbox::EMUPATCH(D3DDevice_LoadVertexShader_4__LTCG_eax1), PATCH_HLE_D3D),
+	PATCH_ENTRY("D3DDevice_LoadVertexShader_4", xbox::EMUPATCH(D3DDevice_LoadVertexShader_4), 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),
@@ -131,92 +126,84 @@ 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", 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_SetFlickerFilter_0", xbox::EMUPATCH(D3DDevice_SetFlickerFilter_0), 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__LTCG_ebx1", xbox::EMUPATCH(D3DDevice_SetIndices_4__LTCG_ebx1), PATCH_HLE_D3D),
+    PATCH_ENTRY("D3DDevice_SetIndices_4", xbox::EMUPATCH(D3DDevice_SetIndices_4), 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__LTCG_eax1", xbox::EMUPATCH(D3DDevice_SetPalette_4__LTCG_eax1), PATCH_HLE_D3D),
+	PATCH_ENTRY("D3DDevice_SetPalette_4", xbox::EMUPATCH(D3DDevice_SetPalette_4), PATCH_HLE_D3D),
 	PATCH_ENTRY("D3DDevice_SetPixelShader", xbox::EMUPATCH(D3DDevice_SetPixelShader), PATCH_HLE_D3D),
-	//PATCH_ENTRY("D3DDevice_SetPixelShaderConstant", xbox::EMUPATCH(D3DDevice_SetPixelShaderConstant), PATCH_HLE_D3D),
+	//PATCH_ENTRY("D3DDevice_SetPixelShaderConstant_4", xbox::EMUPATCH(D3DDevice_SetPixelShaderConstant_4), 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_eax_handle", xbox::EMUPATCH(D3DDevice_SetPixelShader_0__LTCG_eax_handle), 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__LTCG_ecx1_eax2", xbox::EMUPATCH(D3DDevice_SetRenderTarget_0__LTCG_ecx1_eax2), PATCH_HLE_D3D),
+	PATCH_ENTRY("D3DDevice_SetRenderTarget_0", xbox::EMUPATCH(D3DDevice_SetRenderTarget_0), 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_eax1_edi2_ebx3", xbox::EMUPATCH(D3DDevice_SetStreamSource_0__LTCG_eax1_edi2_ebx3), 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__LTCG_eax1_ebx2", xbox::EMUPATCH(D3DDevice_SetStreamSource_4__LTCG_eax1_ebx2), PATCH_HLE_D3D),
+	PATCH_ENTRY("D3DDevice_SetStreamSource_4", xbox::EMUPATCH(D3DDevice_SetStreamSource_4), 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", xbox::EMUPATCH(D3DDevice_SetStreamSource_8), PATCH_HLE_D3D),
-	PATCH_ENTRY("D3DDevice_SetStreamSource_8__LTCG_edx1", xbox::EMUPATCH(D3DDevice_SetStreamSource_8__LTCG_edx1), 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_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_eax2", xbox::EMUPATCH(D3DDevice_SetTexture_4__LTCG_eax2), 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_eax1", xbox::EMUPATCH(D3DDevice_SetTexture_4__LTCG_eax1), 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_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__LTCG_edi1", xbox::EMUPATCH(D3DDevice_SetVertexData4f_16__LTCG_edi1), PATCH_HLE_D3D),
+	PATCH_ENTRY("D3DDevice_SetVertexData4f_16", xbox::EMUPATCH(D3DDevice_SetVertexData4f_16), 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__LTCG_ebx1", xbox::EMUPATCH(D3DDevice_SetVertexShader_0__LTCG_ebx1), PATCH_HLE_D3D),
+	PATCH_ENTRY("D3DDevice_SetVertexShader_0", xbox::EMUPATCH(D3DDevice_SetVertexShader_0), 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__LTCG_edx3", xbox::EMUPATCH(D3DDevice_SetVertexShaderConstant_8__LTCG_edx3), PATCH_HLE_D3D),
+	PATCH_ENTRY("D3DDevice_SetVertexShaderConstant_8", xbox::EMUPATCH(D3DDevice_SetVertexShaderConstant_8), 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__LTCG_eax1", xbox::EMUPATCH(D3DDevice_Swap_0__LTCG_eax1), PATCH_HLE_D3D),
+	PATCH_ENTRY("D3DDevice_Swap_0", xbox::EMUPATCH(D3DDevice_Swap_0), 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__LTCG_eax1", xbox::EMUPATCH(D3D_BlockOnTime_4__LTCG_eax1), PATCH_HLE_D3D),
+	PATCH_ENTRY("D3D_BlockOnTime_4", xbox::EMUPATCH(D3D_BlockOnTime_4), 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_0__LTCG_edi1", xbox::EMUPATCH(D3D_DestroyResource_0__LTCG_edi1), PATCH_HLE_D3D),
+    PATCH_ENTRY("D3D_DestroyResource__LTCG", xbox::EMUPATCH(D3D_DestroyResource__LTCG), 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_eax4_ebx6", xbox::EMUPATCH(Direct3D_CreateDevice_16__LTCG_eax4_ebx6), 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_eax4_ecx6", xbox::EMUPATCH(Direct3D_CreateDevice_16__LTCG_eax4_ecx6), 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__LTCG_eax1_ecx3", xbox::EMUPATCH(Direct3D_CreateDevice_4__LTCG_eax1_ecx3), PATCH_HLE_D3D),
+	PATCH_ENTRY("Direct3D_CreateDevice_4", xbox::EMUPATCH(Direct3D_CreateDevice_4), 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,7 +211,6 @@ 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:
@@ -221,7 +220,6 @@ 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,84 +514,12 @@ 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();
 
-	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 (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) {
+	// 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")) {
 
 		std::string chihiroMediaBoardRom = g_DataFilePath + "/EmuDisk/" + MediaBoardRomFile;
 		if (!std::filesystem::exists(chihiroMediaBoardRom)) {
@@ -652,9 +580,82 @@ 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,7 +26,6 @@
 // ******************************************************************
 
 #include <core\kernel\exports\xboxkrnl.h>
-#include <chrono>
 #include <unordered_map>
 #include <shared_mutex>
 #include "Windows.h"

src/gui/WndMain.cpp

@@ -70,9 +70,6 @@
 
 #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;
 
@@ -981,49 +978,6 @@ 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];
@@ -1151,7 +1105,7 @@ LRESULT CALLBACK WndMain::WndProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lP
 				else {
 					g_Settings->m_core.KrnlDebugMode = DM_NONE;
 				}
-				PopupInfo(m_hwnd, popup_will_not_take_effect_until_the_next_emulation);
+				PopupInfo(m_hwnd, "This will not take effect until the next time emulation is started.");
 
 				RefreshMenus();
 
@@ -1758,36 +1712,6 @@ 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);
@@ -2326,20 +2250,6 @@ 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,7 +31,6 @@
 #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,13 +763,6 @@ 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,10 +354,6 @@
 #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
@@ -365,7 +361,7 @@
 #ifdef APSTUDIO_INVOKED
 #ifndef APSTUDIO_READONLY_SYMBOLS
 #define _APS_NEXT_RESOURCE_VALUE        139
-#define _APS_NEXT_COMMAND_VALUE         40121
+#define _APS_NEXT_COMMAND_VALUE         40117
 #define _APS_NEXT_CONTROL_VALUE         1308
 #define _APS_NEXT_SYMED_VALUE           109
 #endif