xrRender/HW.cpp and dx10HW.cpp: code cleanup and refactoring

Author: Xottab-DUTY

src/Layers/xrRender/HW.cpp

@@ -12,15 +12,8 @@ void free_vid_mode_list();
 
 CHW HW;
 
-CHW::CHW()
-{
-
-}
-
-CHW::~CHW()
-{
-
-}
+CHW::CHW() {}
+CHW::~CHW() {}
 
 //////////////////////////////////////////////////////////////////////
 // Construction/Destruction
@@ -30,7 +23,7 @@ void CHW::CreateD3D()
     hD3D = XRay::LoadModule(GEnv.isDedicatedServer ? "xrD3D9-Null" : "d3d9.dll");
     R_ASSERT2(hD3D->exist(), "Can't find 'd3d9.dll'\nPlease install latest version of DirectX before running this program");
 
-    typedef IDirect3D9* WINAPI _Direct3DCreate9(UINT SDKVersion);
+    using _Direct3DCreate9 = IDirect3D9* WINAPI(UINT SDKVersion);
     auto createD3D = (_Direct3DCreate9*)hD3D->getProcAddress("Direct3DCreate9");
     R_ASSERT(createD3D);
     pD3D = createD3D(D3D_SDK_VERSION);
@@ -49,11 +42,8 @@ void CHW::CreateDevice(HWND m_hWnd, bool move_window)
     CreateD3D();
 
     bool bWindowed = !psDeviceFlags.is(rsFullscreen);
-
-#ifndef _EDITOR
     if (GEnv.isDedicatedServer)
         bWindowed = true;
-#endif
 
     m_DriverType = Caps.bForceGPU_REF ? D3DDEVTYPE_REF : D3DDEVTYPE_HAL;
 
@@ -64,11 +54,11 @@ void CHW::CreateDevice(HWND m_hWnd, bool move_window)
     R_CHK(pD3D->GetAdapterIdentifier(DevAdapter, 0, &adapterID));
     Msg("* GPU [vendor:%X]-[device:%X]: %s", adapterID.VendorId, adapterID.DeviceId, adapterID.Description);
 
-    u16 drv_Product    = HIWORD(adapterID.DriverVersion.HighPart);
-    u16 drv_Version    = LOWORD(adapterID.DriverVersion.HighPart);
-    u16 drv_SubVersion = HIWORD(adapterID.DriverVersion.LowPart);
-    u16 drv_Build      = LOWORD(adapterID.DriverVersion.LowPart);
-    Msg("* GPU driver: %d.%d.%d.%d", u32(drv_Product), u32(drv_Version), u32(drv_SubVersion), u32(drv_Build));
+    const u16 driverProduct    = HIWORD(adapterID.DriverVersion.HighPart);
+    const u16 driverVersion    = LOWORD(adapterID.DriverVersion.HighPart);
+    const u16 driverSubVersion = HIWORD(adapterID.DriverVersion.LowPart);
+    const u16 driverBuild      = LOWORD(adapterID.DriverVersion.LowPart);
+    Msg("* GPU driver: %d.%d.%d.%d", u32(driverProduct), u32(driverVersion), u32(driverSubVersion), u32(driverBuild));
 
     Caps.id_vendor = adapterID.VendorId;
     Caps.id_device = adapterID.DeviceId;
@@ -134,12 +124,9 @@ void CHW::CreateDevice(HWND m_hWnd, bool move_window)
     D3DPRESENT_PARAMETERS& P = DevPP;
     ZeroMemory(&P, sizeof(P));
 
-#ifndef _EDITOR
     selectResolution(P.BackBufferWidth, P.BackBufferHeight, bWindowed);
-#endif
+
     // Back buffer
-    //. P.BackBufferWidth       = dwWidth;
-    //. P.BackBufferHeight      = dwHeight;
     P.BackBufferFormat = fTarget;
     P.BackBufferCount = 1;
 
@@ -170,23 +157,23 @@ void CHW::CreateDevice(HWND m_hWnd, bool move_window)
     }
 
     // Create the device
-    u32 GPU = selectGPU();
-    HRESULT R = HW.pD3D->CreateDevice(DevAdapter, m_DriverType, m_hWnd,
+    const auto GPU = selectGPU();
+    auto result = HW.pD3D->CreateDevice(DevAdapter, m_DriverType, m_hWnd,
         GPU | D3DCREATE_MULTITHREADED, //. ? locks at present
         &P, &pDevice);
 
-    if (FAILED(R))
+    if (FAILED(result))
     {
-        R = HW.pD3D->CreateDevice(DevAdapter, m_DriverType, m_hWnd,
+        result = HW.pD3D->CreateDevice(DevAdapter, m_DriverType, m_hWnd,
             GPU | D3DCREATE_MULTITHREADED, //. ? locks at present
             &P, &pDevice);
     }
-    if (D3DERR_DEVICELOST == R)
+    if (D3DERR_DEVICELOST == result)
     {
         // Fatal error! Cannot create rendering device AT STARTUP !!!
         Msg("Failed to initialize graphics hardware.\n"
             "Please try to restart the game.\n"
-            "CreateDevice returned 0x%08x(D3DERR_DEVICELOST)", R);
+            "CreateDevice returned 0x%08x(D3DERR_DEVICELOST)", result);
         FlushLog();
         MessageBox(nullptr, "Failed to initialize graphics hardware.\nPlease try to restart the game.", "Error!",
             MB_OK | MB_ICONERROR);
@@ -211,10 +198,9 @@ void CHW::CreateDevice(HWND m_hWnd, bool move_window)
     u32 memory = pDevice->GetAvailableTextureMem();
     Msg("*   Texture memory: %d M", memory / (1024 * 1024));
     Msg("*        DDI-level: %2.1f", float(D3DXGetDriverLevel(pDevice)) / 100.f);
-#ifndef _EDITOR
+
     updateWindowProps(m_hWnd);
     fill_vid_mode_list(this);
-#endif
 }
 
 void CHW::DestroyDevice()
@@ -249,7 +235,6 @@ void CHW::Reset(HWND hwnd)
     _RELEASE(pBaseZB);
     _RELEASE(pBaseRT);
 
-#ifndef _EDITOR
     bool bWindowed = true;
     if (!GEnv.isDedicatedServer)
         bWindowed = !psDeviceFlags.is(rsFullscreen);
@@ -268,25 +253,25 @@ void CHW::Reset(HWND hwnd)
         DevPP.PresentationInterval = D3DPRESENT_INTERVAL_IMMEDIATE;
         DevPP.FullScreen_RefreshRateInHz = D3DPRESENT_RATE_DEFAULT;
     }
-#endif
 
     while (true)
     {
-        HRESULT _hr = HW.pDevice->Reset(&DevPP);
-        if (SUCCEEDED(_hr))
+        auto result = HW.pDevice->Reset(&DevPP);
+        
+        if (SUCCEEDED(result))
             break;
-        Msg("! ERROR: [%dx%d]: %s", DevPP.BackBufferWidth, DevPP.BackBufferHeight, xrDebug::ErrorToString(_hr));
+
+        Msg("! ERROR: [%dx%d]: %s", DevPP.BackBufferWidth, DevPP.BackBufferHeight, xrDebug::ErrorToString(result));
         Sleep(100);
     }
     R_CHK(pDevice->GetRenderTarget(0, &pBaseRT));
     R_CHK(pDevice->GetDepthStencilSurface(&pBaseZB));
 #ifdef DEBUG
     R_CHK(pDevice->CreateStateBlock(D3DSBT_ALL, &dwDebugSB));
 #endif
-#ifndef _EDITOR
+
     updateWindowProps(hwnd);
     ShowWindow(hwnd, SW_SHOWNORMAL);
-#endif
 }
 
 D3DFORMAT CHW::selectDepthStencil(D3DFORMAT fTarget)
@@ -319,36 +304,32 @@ D3DFORMAT CHW::selectDepthStencil(D3DFORMAT fTarget)
 void CHW::selectResolution(u32& dwWidth, u32& dwHeight, BOOL bWindowed)
 {
     fill_vid_mode_list(this);
-#ifndef _EDITOR
+
     if (GEnv.isDedicatedServer)
     {
         dwWidth = 640;
         dwHeight = 480;
+        return;
     }
-    else
-#endif
+
+    if (bWindowed)
     {
-        if (bWindowed)
-        {
-            dwWidth = psCurrentVidMode[0];
-            dwHeight = psCurrentVidMode[1];
-        }
-        else // check
-        {
-#ifndef _EDITOR
-            string64 buff;
-            xr_sprintf(buff, sizeof(buff), "%dx%d", psCurrentVidMode[0], psCurrentVidMode[1]);
-
-            if (_ParseItem(buff, AvailableVideoModes.data()) == u32(-1)) // not found
-            { // select safe
-                xr_sprintf(buff, sizeof(buff), "vid_mode %s", AvailableVideoModes[0].name);
-                Console->Execute(buff);
-            }
+        dwWidth = psCurrentVidMode[0];
+        dwHeight = psCurrentVidMode[1];
+    }
+    else // check
+    {
+        string64 buff;
+        xr_sprintf(buff, sizeof(buff), "%dx%d", psCurrentVidMode[0], psCurrentVidMode[1]);
 
-            dwWidth = psCurrentVidMode[0];
-            dwHeight = psCurrentVidMode[1];
-#endif
+        if (_ParseItem(buff, AvailableVideoModes.data()) == u32(-1)) // not found
+        { // select safe
+            xr_sprintf(buff, sizeof(buff), "vid_mode %s", AvailableVideoModes[0].name);
+            Console->Execute(buff);
         }
+
+        dwWidth = psCurrentVidMode[0];
+        dwHeight = psCurrentVidMode[1];
     }
 }
 
@@ -367,51 +348,59 @@ u32 CHW::selectPresentInterval()
     return D3DPRESENT_INTERVAL_DEFAULT;
 }
 
-u32 CHW::selectGPU()
+void CheckForIntelGMA(CHWCaps& Caps)
 {
-#if RENDER == R_R1
-    BOOL isIntelGMA = FALSE;
-
-    if (Caps.id_vendor == 0x8086)
-    { // Intel
-
-#define GMA_SL_SIZE 43
+    bool isIntelGMA = false;
 
-        DWORD IntelGMA_SoftList[GMA_SL_SIZE] = {0x2782, 0x2582, 0x2792, 0x2592, 0x2772, 0x2776, 0x27A2, 0x27A6, 0x27AE,
-            0x2982, 0x2983, 0x2992, 0x2993, 0x29A2, 0x29A3, 0x2972, 0x2973, 0x2A02, 0x2A03, 0x2A12, 0x2A13, 0x29C2,
-            0x29C3, 0x29B2, 0x29B3, 0x29D2, 0x29D3,
-
-            0x2A42, 0x2A43, 0x2E02, 0x2E03, 0x2E12, 0x2E13, 0x2E22, 0x2E23, 0x2E32, 0x2E33, 0x2E42, 0x2E43, 0x2E92,
-            0x2E93, 0x0042, 0x0046};
+    if (Caps.id_vendor == 0x8086) // Intel
+    {
+        constexpr auto GMA_SL_SIZE = 43;
+        constexpr DWORD IntelGMA_SoftList[GMA_SL_SIZE] =
+        {
+            0x2782, 0x2582, 0x2792, 0x2592, 0x2772, 0x2776, 0x27A2, 0x27A6, 0x27AE,
+            0x2982, 0x2983, 0x2992, 0x2993, 0x29A2, 0x29A3, 0x2972, 0x2973, 0x2A02,
+            0x2A03, 0x2A12, 0x2A13, 0x29C2, 0x29C3, 0x29B2, 0x29B3, 0x29D2, 0x29D3,
+            0x2A42, 0x2A43, 0x2E02, 0x2E03, 0x2E12, 0x2E13, 0x2E22, 0x2E23, 0x2E32,
+            0x2E33, 0x2E42, 0x2E43, 0x2E92, 0x2E93, 0x0042, 0x0046
+        };
 
         for (int idx = 0; idx < GMA_SL_SIZE; ++idx)
+        {
             if (IntelGMA_SoftList[idx] == Caps.id_device)
             {
-                isIntelGMA = TRUE;
+                isIntelGMA = true;
                 break;
             }
+        }
     }
 
     if (isIntelGMA)
+    {
         switch (ps_r1_SoftwareSkinning)
         {
         case 0:
-            Msg("* Enabling software skinning");
+            Log("* Enabling software skinning");
             ps_r1_SoftwareSkinning = 1;
             break;
-        case 1: Msg("* Using software skinning"); break;
+        case 1: Log("* Using software skinning"); break;
         case 2:
-            Msg("* WARNING: Using hardware skinning");
-            Msg("*   setting 'r1_software_skinning' to '1' may improve performance");
+            Log("* WARNING: Using hardware skinning");
+            Log("*   setting 'r1_software_skinning' to '1' may improve performance");
             break;
         }
+    }
     else if (ps_r1_SoftwareSkinning == 1)
     {
         Msg("* WARNING: Using software skinning");
         Msg("*   setting 'r1_software_skinning' to '0' should improve performance");
     }
+}
 
-#endif // RENDER == R_R1
+u32 CHW::selectGPU()
+{
+#if RENDER == R_R1
+    CheckForIntelGMA(Caps);
+#endif
 
     if (Caps.bForceGPU_SW)
         return D3DCREATE_SOFTWARE_VERTEXPROCESSING;
@@ -423,62 +412,51 @@ u32 CHW::selectGPU()
     {
         if (Caps.bForceGPU_NonPure)
             return D3DCREATE_HARDWARE_VERTEXPROCESSING;
-        else
-        {
-            if (caps.DevCaps & D3DDEVCAPS_PUREDEVICE)
-                return D3DCREATE_HARDWARE_VERTEXPROCESSING | D3DCREATE_PUREDEVICE;
-            else
-                return D3DCREATE_HARDWARE_VERTEXPROCESSING;
-        }
+        if (caps.DevCaps & D3DDEVCAPS_PUREDEVICE)
+            return D3DCREATE_HARDWARE_VERTEXPROCESSING | D3DCREATE_PUREDEVICE;
+        return D3DCREATE_HARDWARE_VERTEXPROCESSING;
         // return D3DCREATE_MIXED_VERTEXPROCESSING;
     }
-    else
-        return D3DCREATE_SOFTWARE_VERTEXPROCESSING;
+
+    return D3DCREATE_SOFTWARE_VERTEXPROCESSING;
 }
 
 u32 CHW::selectRefresh(u32 dwWidth, u32 dwHeight, D3DFORMAT fmt)
 {
     if (psDeviceFlags.is(rsRefresh60hz))
-    {
         return D3DPRESENT_RATE_DEFAULT;
-    }
-    else
+
+    auto selected = D3DPRESENT_RATE_DEFAULT;
+    const auto count = pD3D->GetAdapterModeCount(DevAdapter, fmt);
+    for (u32 I = 0; I < count; I++)
     {
-        u32 selected = D3DPRESENT_RATE_DEFAULT;
-        u32 count = pD3D->GetAdapterModeCount(DevAdapter, fmt);
-        for (u32 I = 0; I < count; I++)
+        D3DDISPLAYMODE Mode;
+        pD3D->EnumAdapterModes(DevAdapter, fmt, I, &Mode);
+        if (Mode.Width == dwWidth && Mode.Height == dwHeight)
         {
-            D3DDISPLAYMODE Mode;
-            pD3D->EnumAdapterModes(DevAdapter, fmt, I, &Mode);
-            if (Mode.Width == dwWidth && Mode.Height == dwHeight)
-            {
-                //if (Mode.RefreshRate > selected)
-                //    selected = Mode.RefreshRate;
-                if (Mode.RefreshRate <= maxRefreshRate && Mode.RefreshRate>selected)
-                    selected = Mode.RefreshRate;  //ECO_RENDER modif.
-            }
+            //if (Mode.RefreshRate > selected)
+            //    selected = Mode.RefreshRate;
+            if (Mode.RefreshRate <= maxRefreshRate && Mode.RefreshRate>selected)
+                selected = Mode.RefreshRate;  //ECO_RENDER modif.
         }
-        return selected;
     }
+    return selected;
 }
 
 BOOL CHW::support(D3DFORMAT fmt, DWORD type, DWORD usage)
 {
-    HRESULT hr = pD3D->CheckDeviceFormat(DevAdapter, m_DriverType, Caps.fTarget, usage, (D3DRESOURCETYPE)type, fmt);
-    if (FAILED(hr))
+    auto result = pD3D->CheckDeviceFormat(DevAdapter, m_DriverType, Caps.fTarget, usage, (D3DRESOURCETYPE)type, fmt);
+    if (FAILED(result))
         return FALSE;
-    else
-        return TRUE;
+    return TRUE;
 }
 
 void CHW::updateWindowProps(HWND m_hWnd)
 {
     bool bWindowed = !psDeviceFlags.is(rsFullscreen);
 
-#ifndef _EDITOR
     if (GEnv.isDedicatedServer)
         bWindowed = true;
-#endif
 
     u32 dwWindowStyle = 0;
     // Set window properties depending on what mode were in.
@@ -536,8 +514,7 @@ void CHW::updateWindowProps(HWND m_hWnd)
     }
     else
     {
-        SetWindowLong(m_hWnd, GWL_STYLE, dwWindowStyle = (WS_POPUP | WS_VISIBLE));
-        SetWindowLong(m_hWnd, GWL_EXSTYLE, WS_EX_TOPMOST);
+        SetWindowLong(m_hWnd, GWL_STYLE, dwWindowStyle = WS_POPUP | WS_VISIBLE);
     }
 
     if (!GEnv.isDedicatedServer)