Fix the colors of Borderless Windowed/Keep Res mode to match Fullscreen (Standard)

This (lower brightness) has been the major downside of using Borderless for years, so this is a fix of great value to MTA.

Author: Dutchman101

Client/core/DXHook/CProxyDirect3D9.cpp

@@ -246,6 +246,30 @@ HRESULT CProxyDirect3D9::CreateDevice(UINT Adapter, D3DDEVTYPE DeviceType, HWND
     hResult =
         HandleCreateDeviceResult(hResult, m_pDevice, Adapter, DeviceType, hFocusWindow, BehaviorFlags, pPresentationParameters, ppReturnedDeviceInterface);
 
+    // After successful device creation
+    if (SUCCEEDED(hResult) && *ppReturnedDeviceInterface)
+    {
+        // Check if we're in borderless mode
+        bool bIsBorderlessMode = pPresentationParameters->Windowed == TRUE;
+
+        if (bIsBorderlessMode)
+        {
+            // Enable sRGB correction for borderless mode to compensate for DWM composition
+            CProxyDirect3DDevice9* pProxyDevice = static_cast<CProxyDirect3DDevice9*>(*ppReturnedDeviceInterface);
+
+            // Set initial render states for proper color handling
+            pProxyDevice->SetRenderState(D3DRS_SRGBWRITEENABLE, TRUE);
+
+            // Configure samplers for sRGB texture reading
+            for (DWORD i = 0; i < 8; i++)
+            {
+                pProxyDevice->SetSamplerState(i, D3DSAMP_SRGBTEXTURE, TRUE);
+            }
+
+            WriteDebugEvent("Applied sRGB color correction for borderless mode");
+        }
+    }
+
     return hResult;
 }
 

Client/core/DXHook/CProxyDirect3DDevice9.cpp

@@ -15,6 +15,7 @@
 bool                                    g_bInGTAScene = false;
 CProxyDirect3DDevice9*                  g_pProxyDevice = NULL;
 CProxyDirect3DDevice9::SD3DDeviceState* g_pDeviceState = NULL;
+SGammaState                             g_GammaState;
 
 // Proxy constructor and destructor.
 CProxyDirect3DDevice9::CProxyDirect3DDevice9(IDirect3DDevice9* pDevice)
@@ -123,6 +124,22 @@ CProxyDirect3DDevice9::~CProxyDirect3DDevice9()
 {
     WriteDebugEvent(SString("CProxyDirect3DDevice9::~CProxyDirect3DDevice9 %08x", this));
 
+    // Reset gamma state when device is destroyed
+    if (g_pProxyDevice == this)
+    {
+        // Restore original gamma if we had stored it
+        if (g_GammaState.bOriginalGammaStored && m_pDevice)
+        {
+            m_pDevice->SetGammaRamp(g_GammaState.lastSwapChain, 0, &g_GammaState.originalGammaRamp);
+            WriteDebugEvent("Restored original gamma ramp on device destruction");
+        }
+        
+        // Reset gamma state
+        g_GammaState.bOriginalGammaStored = false;
+        g_GammaState.bLastWasBorderless = false;
+        ZeroMemory(&g_GammaState.originalGammaRamp, sizeof(g_GammaState.originalGammaRamp));
+    }
+    
     // Release our reference to the wrapped device
     // Note: We don't check m_ulRefCount here because destructor is only called
     // when Release() determined the count reached 0
@@ -374,6 +391,12 @@ HRESULT CProxyDirect3DDevice9::Reset(D3DPRESENT_PARAMETERS* pPresentationParamet
         return D3DERR_INVALIDCALL;
     }
 
+    // Reset gamma state since display mode might change
+    g_GammaState.bOriginalGammaStored = false;
+    g_GammaState.bLastWasBorderless = false;
+    ZeroMemory(&g_GammaState.originalGammaRamp, sizeof(g_GammaState.originalGammaRamp));
+    WriteDebugEvent("Reset gamma state due to device reset");
+    
     // Check cooperative level before attempting reset
     HRESULT hCoopLevel = m_pDevice->TestCooperativeLevel();
     if (hCoopLevel == D3DERR_DEVICELOST)
@@ -473,6 +496,7 @@ HRESULT CProxyDirect3DDevice9::Reset(D3DPRESENT_PARAMETERS* pPresentationParamet
     return hResult;
 }
 
+
 HRESULT CProxyDirect3DDevice9::Present(CONST RECT* pSourceRect, CONST RECT* pDestRect, HWND hDestWindowOverride, CONST RGNDATA* pDirtyRegion)
 {
     CDirect3DEvents9::OnPresent(m_pDevice);
@@ -508,12 +532,99 @@ HRESULT CProxyDirect3DDevice9::SetDialogBoxMode(BOOL bEnableDialogs)
 
 VOID CProxyDirect3DDevice9::SetGammaRamp(UINT iSwapChain, DWORD Flags, CONST D3DGAMMARAMP* pRamp)
 {
-    m_pDevice->SetGammaRamp(iSwapChain, Flags, pRamp);
+    // Validate inputs first
+    if (!pRamp)
+    {
+        WriteDebugEvent("CProxyDirect3DDevice9::SetGammaRamp - Invalid gamma ramp pointer");
+        return;
+    }
+
+    // Validate swap chain index
+    if (iSwapChain >= GetNumberOfSwapChains())
+    {
+        WriteDebugEvent(SString("CProxyDirect3DDevice9::SetGammaRamp - Invalid swap chain index: %d", iSwapChain));
+        return;
+    }
+
+    // Get current display mode state - use a timeout to avoid race conditions during mode transitions
+    CVideoModeManagerInterface* pVideoModeManager = GetVideoModeManager();
+    if (!pVideoModeManager)
+    {
+        // Fallback to original behavior if video mode manager is unavailable
+        m_pDevice->SetGammaRamp(iSwapChain, Flags, pRamp);
+        return;
+    }
+
+    bool bIsBorderlessMode = pVideoModeManager->IsDisplayModeWindowed() || pVideoModeManager->IsDisplayModeFullScreenWindow();
+
+    // Store original gamma ramp on first call or mode change
+    if (!g_GammaState.bOriginalGammaStored || g_GammaState.lastSwapChain != iSwapChain || g_GammaState.bLastWasBorderless != bIsBorderlessMode)
+    {
+        if (!bIsBorderlessMode || !g_GammaState.bOriginalGammaStored)
+        {
+            // In fullscreen mode or first time - this is likely the original gamma
+            g_GammaState.originalGammaRamp = *pRamp;
+            g_GammaState.bOriginalGammaStored = true;
+            g_GammaState.lastSwapChain = iSwapChain;
+        }
+        g_GammaState.bLastWasBorderless = bIsBorderlessMode;
+    }
+
+    if (bIsBorderlessMode)
+    {
+        // Apply brightness and contrast adjustment to match fullscreen mode
+        D3DGAMMARAMP adjustedRamp = *pRamp;
+
+        // Use lighter gamma correction to prevent darkening effect
+        // and optimize brightness boost for better visibility
+        const float fGammaCorrection = 1.0f / 1.3f;
+        const float fBrightnessBoost = 1.4f;
+
+        for (int i = 0; i < 256; i++)
+        {
+            // Convert to normalized float (0.0 - 1.0)
+            float fRed = static_cast<float>(pRamp->red[i]) / 65535.0f;
+            float fGreen = static_cast<float>(pRamp->green[i]) / 65535.0f;
+            float fBlue = static_cast<float>(pRamp->blue[i]) / 65535.0f;
+
+            // Clamp input values to valid range
+            fRed = std::max(0.0f, std::min(1.0f, fRed));
+            fGreen = std::max(0.0f, std::min(1.0f, fGreen));
+            fBlue = std::max(0.0f, std::min(1.0f, fBlue));
+
+            // Apply gentler gamma correction first
+            fRed = powf(fRed, fGammaCorrection);
+            fGreen = powf(fGreen, fGammaCorrection);
+            fBlue = powf(fBlue, fGammaCorrection);
+
+            // Then apply balanced brightness boost
+            fRed = std::min(1.0f, fRed * fBrightnessBoost);
+            fGreen = std::min(1.0f, fGreen * fBrightnessBoost);
+            fBlue = std::min(1.0f, fBlue * fBrightnessBoost);
+
+            // Convert back to WORD values with proper rounding
+            adjustedRamp.red[i] = static_cast<WORD>(fRed * 65535.0f + 0.5f);
+            adjustedRamp.green[i] = static_cast<WORD>(fGreen * 65535.0f + 0.5f);
+            adjustedRamp.blue[i] = static_cast<WORD>(fBlue * 65535.0f + 0.5f);
+        }
+
+        // Set the adjusted gamma ramp
+        m_pDevice->SetGammaRamp(iSwapChain, Flags, &adjustedRamp);
+        
+        WriteDebugEvent("Applied gamma adjustment for borderless windowed mode");
+    }
+    else
+    {
+        // In exclusive fullscreen mode, use the original gamma ramp
+        m_pDevice->SetGammaRamp(iSwapChain, Flags, pRamp);
+        
+        WriteDebugEvent("Applied original gamma ramp for fullscreen mode");
+    }
 }
 
 VOID CProxyDirect3DDevice9::GetGammaRamp(UINT iSwapChain, D3DGAMMARAMP* pRamp)
 {
-    m_pDevice->GetGammaRamp(iSwapChain, pRamp);
+    return m_pDevice->GetGammaRamp(iSwapChain, pRamp);
 }
 
 HRESULT CProxyDirect3DDevice9::CreateTexture(UINT Width, UINT Height, UINT Levels, DWORD Usage, D3DFORMAT Format, D3DPOOL Pool, IDirect3DTexture9** ppTexture,

Client/core/DXHook/CProxyDirect3DDevice9.h

@@ -557,3 +557,19 @@ interface CProxyDirect3DDevice9 : public IDirect3DDevice9
 
 extern CProxyDirect3DDevice9*                  g_pProxyDevice;
 extern CProxyDirect3DDevice9::SD3DDeviceState* g_pDeviceState;
+
+// Add gamma state management
+struct SGammaState
+{
+    volatile bool     bOriginalGammaStored;
+    volatile bool     bLastWasBorderless;
+    D3DGAMMARAMP      originalGammaRamp;
+    volatile UINT     lastSwapChain;
+    
+    SGammaState() : bOriginalGammaStored(false), bLastWasBorderless(false), lastSwapChain(0)
+    {
+        ZeroMemory(&originalGammaRamp, sizeof(originalGammaRamp));
+    }
+};
+
+extern SGammaState g_GammaState;

Client/core/Graphics/CVideoModeManager.cpp

@@ -42,9 +42,9 @@ class CVideoModeManager : public CVideoModeManagerInterface
     virtual bool GetRequiredDisplayResolution(int& iOutWidth, int& iOutHeight, int& iOutColorBits, int& iOutAdapterIndex) override;
     virtual int  GetFullScreenStyle() override { return m_iCurrentFullscreenStyle; }
     virtual bool IsDisplayModeWindowed() override;
+    virtual bool IsDisplayModeFullScreenWindow() override;
 
     bool    IsDisplayModeFullScreen();
-    bool    IsDisplayModeFullScreenWindow();
     bool    GetCurrentAdapterRect(LPRECT pOutRect);
     SString GetCurrentAdapterDeviceName();
 

Client/core/Graphics/CVideoModeManager.h

@@ -37,6 +37,7 @@ class CVideoModeManagerInterface
     virtual bool GetRequiredDisplayResolution(int& iOutWidth, int& iOutHeight, int& iOutColorBits, int& iOutAdapterIndex) = 0;
     virtual int  GetFullScreenStyle() = 0;
     virtual bool IsDisplayModeWindowed() = 0;
+    virtual bool IsDisplayModeFullScreenWindow() = 0;
 };
 
 CVideoModeManagerInterface* GetVideoModeManager();