Merge branch 'master' into fix/sort-resolution-dialog

Author: MohabCodeX

Client/core/CGUI.cpp

@@ -700,9 +700,21 @@ bool CLocalGUI::InputGoesToGUI()
     if (!pGUI)
         return false;
 
-    // Here we're supposed to check if things like menues are up, console is up or the chatbox is expecting input
-    // If the console is visible OR the chat is expecting input OR the mainmenu is visible
-    return (IsConsoleVisible() || IsMainMenuVisible() || IsChatBoxInputEnabled() || m_bForceCursorVisible || pGUI->GetGUIInputEnabled() ||
+    bool shouldShowCursorForGUI = false;
+    if (pGUI->GetGUIInputEnabled())
+    {
+        eInputMode inputMode = pGUI->GetGUIInputMode();
+        if (inputMode == INPUTMODE_NO_BINDS_ON_EDIT)
+        {
+            shouldShowCursorForGUI = true;
+        }
+        else if (inputMode == INPUTMODE_NO_BINDS)
+        {
+            shouldShowCursorForGUI = false;
+        }
+    }
+    
+    return (IsConsoleVisible() || IsMainMenuVisible() || IsChatBoxInputEnabled() || m_bForceCursorVisible || shouldShowCursorForGUI ||
             !CCore::GetSingleton().IsFocused() || IsWebRequestGUIVisible());
 }
 

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/DXHook/CProxyDirect3DVertexBuffer.cpp

@@ -2,8 +2,8 @@
  *
  *  PROJECT:     Multi Theft Auto v1.0
  *  LICENSE:     See LICENSE in the top level directory
- *  FILE:
- *  PURPOSE:
+ *  FILE:        core/CProxyDirect3DVertexBuffer.cpp
+ *  PURPOSE:     Direct3D 9 vertex buffer function hooking proxy
  *
  *  Multi Theft Auto is available from https://www.multitheftauto.com/
  *
@@ -86,15 +86,10 @@ HRESULT CProxyDirect3DVertexBuffer::QueryInterface(REFIID riid, void** ppvObj)
 ULONG CProxyDirect3DVertexBuffer::Release()
 {
     // Call original function
-    ULONG count = m_pOriginal->Release();
-
-    if (count == 0)
-    {
-        // now, the Original Object has deleted itself, so do we here
-        delete this;            // destructor will be called automatically
-    }
-
-    return count;
+    ULONG ulRefCount = m_pOriginal->Release();
+    if (ulRefCount == 0)
+        delete this;
+    return ulRefCount;
 }
 
 /////////////////////////////////////////////////////////////

Client/core/DXHook/CProxyDirect3DVertexBuffer.h

@@ -2,13 +2,18 @@
  *
  *  PROJECT:     Multi Theft Auto v1.0
  *  LICENSE:     See LICENSE in the top level directory
- *  FILE:
- *  PURPOSE:
+ *  FILE:        core/CProxyDirect3DVertexBuffer.h
+ *  PURPOSE:     Direct3D 9 vertex buffer function hooking proxy
  *
  *  Multi Theft Auto is available from https://www.multitheftauto.com/
  *
  *****************************************************************************/
 
+#pragma once
+
+#include <d3d9.h>
+#include "CProxyDirect3DDevice9.h"  // Include full definition for SResourceMemory
+
 DEFINE_GUID(CProxyDirect3DVertexBuffer_GUID, 0x128A025E, 0x0100, 0x04F1, 0x40, 0x60, 0x53, 0x19, 0x44, 0x56, 0x59, 0x42);
 
 class CProxyDirect3DVertexBuffer : public IDirect3DVertexBuffer9
@@ -29,7 +34,7 @@ class CProxyDirect3DVertexBuffer : public IDirect3DVertexBuffer9
     HRESULT __stdcall FreePrivateData(REFGUID refguid) { return m_pOriginal->FreePrivateData(refguid); }
     DWORD __stdcall SetPriority(DWORD PriorityNew) { return m_pOriginal->SetPriority(PriorityNew); }
     DWORD __stdcall GetPriority() { return m_pOriginal->GetPriority(); }
-    void __stdcall PreLoad() { return m_pOriginal->PreLoad(); }
+    void __stdcall PreLoad() { m_pOriginal->PreLoad(); }
     D3DRESOURCETYPE __stdcall GetType() { return m_pOriginal->GetType(); }
 
     /*** IDirect3DVertexBuffer9 methods ***/

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();

Client/game_sa/CAudioEngineSA.cpp

@@ -425,14 +425,14 @@ static void __declspec(naked) HOOK_CAEAmbienceTrackManager_CheckForPause()
 
     __asm
     {
-        push    esi
+        pushad
         call    IsAmbientSoundGeneralEnabled
         test    al, al
+        popad
         jnz     continueWithOriginalCode
         mov     dword ptr [esp+8], 0      // Pause by setting 0.0f for the last argument to CAEAudioHardware::SetChannelFrequencyScalingFactor
 
         continueWithOriginalCode:
-        pop     esi
         mov     edi, [esp+8]
         xor     ecx, ecx
         jmp     RETURN_CAEAmbienceTrackManager_CheckForPause

Client/mods/deathmatch/logic/CClientPed.cpp

@@ -2014,6 +2014,13 @@ void CClientPed::SetFrozen(bool bFrozen)
             if (m_pPlayerPed)
             {
                 m_pPlayerPed->GetMatrix(&m_matFrozen);
+                
+                CVector vecFrozenRotation = m_matFrozen.GetRotation();
+                
+                if (vecFrozenRotation.fX == 0.0f && vecFrozenRotation.fY == 0.0f && vecFrozenRotation.fZ == 0.0f)
+                {
+                    m_matFrozen.SetRotation(m_Matrix.GetRotation());
+                }
             }
             else
             {
@@ -3326,6 +3333,12 @@ void CClientPed::ApplyControllerStateFixes(CControllerState& Current)
 
 float CClientPed::GetCurrentRotation()
 {
+    if (IsFrozen())
+    {
+        CVector vecRotation = m_matFrozen.GetRotation();
+        return vecRotation.fZ;
+    }
+    
     if (m_pPlayerPed)
     {
         return m_pPlayerPed->GetCurrentRotation();