Merge branch 'master' into feature/remove-all-domains

Author: omar-o22

Client/core/CAdditionalVertexStreamManager.cpp

@@ -84,9 +84,11 @@ class CAdditionalVertexStreamManager
     void OnVertexBufferRangeInvalidated(IDirect3DVertexBuffer9* pStreamData, uint Offset, uint Size);
 
     static CAdditionalVertexStreamManager* GetSingleton();
+    static CAdditionalVertexStreamManager* GetExistingSingleton();
+    static void DestroySingleton();
 
 protected:
-    void SetAdditionalVertexStream(SCurrentStateInfo& renderState);
+    bool SetAdditionalVertexStream(SCurrentStateInfo& renderState);
     bool UpdateCurrentStateInfo(SCurrentStateInfo& state);
     bool UpdateAdditionalStreamContent(SCurrentStateInfo& state, SAdditionalStreamInfo* pAdditionalStreamInfo, uint ReadOffsetStart, uint ReadSize,
                                        uint WriteOffsetStart, uint WriteSize);

Client/core/CAdditionalVertexStreamManager.h

@@ -265,6 +265,16 @@ void CClientVariables::ValidateValues()
     ClampValue("voicevolume", 0.0f, 1.0f);
     ClampValue("mapalpha", 0, 255);
     ClampValue("mapimage", 0, 1);
+    ClampValue("borderless_gamma_power", 0.5f, 2.0f);
+    ClampValue("borderless_brightness_scale", 0.5f, 2.0f);
+    ClampValue("borderless_contrast_scale", 0.5f, 2.0f);
+    ClampValue("borderless_saturation_scale", 0.5f, 2.0f);
+    ClampValue("borderless_gamma_enabled", false, true);
+    ClampValue("borderless_brightness_enabled", false, true);
+    ClampValue("borderless_contrast_enabled", false, true);
+    ClampValue("borderless_saturation_enabled", false, true);
+    ClampValue("borderless_apply_windowed", false, true);
+    ClampValue("borderless_apply_fullscreen", false, true);
 }
 
 void CClientVariables::LoadDefaults()
@@ -348,6 +358,24 @@ void CClientVariables::LoadDefaults()
     DEFAULT("display_fullscreen_style", 0);                                           // 0-standard 1-borderless 2-borderless keep res 3-borderless stretch
     DEFAULT("display_windowed", 0);                                                   // 0-off 1-on
     DEFAULT("multimon_fullscreen_minimize", 1);                                       // 0-off 1-on
+    DEFAULT("borderless_gamma_power", 0.95f);                                         // Gamma exponent applied to windowed gamma ramp (1.0 = unchanged)
+    DEFAULT("borderless_brightness_scale", 1.03f);                                    // Brightness multiplier for windowed gamma ramp (1.0 = unchanged)
+    DEFAULT("borderless_contrast_scale", 1.0f);                                       // Contrast multiplier for borderless presentation (1.0 = unchanged)
+    DEFAULT("borderless_saturation_scale", 1.0f);                                     // Saturation multiplier for borderless presentation (1.0 = unchanged)
+    DEFAULT("borderless_enable_srgb", false);                                         // Enable sRGB correction when running borderless
+    DEFAULT("borderless_gamma_enabled", false);                                       // Apply gamma adjustment while borderless tuning active
+    DEFAULT("borderless_brightness_enabled", false);                                  // Apply brightness adjustment while borderless tuning active
+    DEFAULT("borderless_contrast_enabled", false);                                    // Apply contrast adjustment while borderless tuning active
+    DEFAULT("borderless_saturation_enabled", false);                                  // Apply saturation adjustment while borderless tuning active
+    DEFAULT("borderless_apply_windowed", false);                                      // Apply display adjustments while windowed/borderless
+    DEFAULT("borderless_apply_fullscreen", false);                                   // Apply display adjustments while in exclusive fullscreen
+
+    if (Exists("borderless_enable_srgb"))
+    {
+    bool legacyEnable = false;
+        Get("borderless_enable_srgb", legacyEnable);
+        Set("borderless_apply_windowed", legacyEnable);
+    }
     DEFAULT("vertical_aim_sensitivity", 0.0015f);                                     // 0.0015f is GTA default setting
     DEFAULT("process_priority", 0);                                                   // 0-normal 1-above normal 2-high
     DEFAULT("process_dpi_aware", false);                                              // Enable DPI awareness in core initialization

Client/core/CClientVariables.cpp

@@ -146,6 +146,11 @@ CCore::CCore()
     // Setup our hooks.
     ApplyHooks();
 
+    m_pModelCacheManager = nullptr;
+    m_iDummyProgressValue = 0;
+    m_DummyProgressTimerHandle = NULL;
+    m_bDummyProgressUpdateAlways = false;
+
     m_iUnminimizeFrameCounter = 0;
     m_bDidRecreateRenderTargets = false;
     m_fMinStreamingMemory = 0;
@@ -187,10 +192,27 @@ CCore::~CCore()
     // Remove input hook
     CMessageLoopHook::GetSingleton().RemoveHook();
 
+    if (m_bWindowsTimerEnabled)
+    {
+        KillTimer(GetHookedWindow(), IDT_TIMER1);
+        m_bWindowsTimerEnabled = false;
+    }
+
+    extern int ms_iDummyProgressTimerCounter;
+
+    if (m_DummyProgressTimerHandle != NULL)
+    {
+        DeleteTimerQueueTimer(NULL, m_DummyProgressTimerHandle, INVALID_HANDLE_VALUE);
+        m_DummyProgressTimerHandle = NULL;
+        ms_iDummyProgressTimerCounter = 0;
+    }
+
     // Delete the mod manager
     delete m_pModManager;
     SAFE_DELETE(m_pMessageBox);
 
+    SAFE_DELETE(m_pModelCacheManager);
+
     // Destroy early subsystems
     m_bModulesLoaded = false;
     DestroyNetwork();
@@ -225,6 +247,8 @@ CCore::~CCore()
     DestroyGUI();
     DestroyXML();
 
+    SAFE_DELETE(g_pLocalization);
+
     // Delete keybinds
     delete m_pKeyBinds;
 
@@ -1072,6 +1096,16 @@ void CCore::CreateXML()
         if (!m_pConfigFile)
         {
             assert(false);
+
+            if (m_pXML)
+            {
+                using PFNReleaseXMLInterface = void (*)();
+                if (auto pfnRelease = reinterpret_cast<PFNReleaseXMLInterface>(m_XMLModule.GetFunctionPointer("ReleaseXMLInterface")))
+                    pfnRelease();
+            }
+
+            m_pXML = NULL;
+            m_XMLModule.UnloadModule();
             return;
         }
 
@@ -1123,10 +1157,14 @@ void CCore::DestroyXML()
     {
         SaveConfig(true);
         delete m_pConfigFile;
+        m_pConfigFile = nullptr;
     }
 
     if (m_pXML)
     {
+        using PFNReleaseXMLInterface = void (*)();
+        if (auto pfnRelease = reinterpret_cast<PFNReleaseXMLInterface>(m_XMLModule.GetFunctionPointer("ReleaseXMLInterface")))
+            pfnRelease();
         m_pXML = NULL;
     }
 

Client/core/CCore.cpp

@@ -358,33 +358,64 @@ CMainMenu::CMainMenu(CGUI* pManager)
 
 CMainMenu::~CMainMenu()
 {
-    // Destroy GUI items
-    delete m_pBackground;
-    delete m_pCanvas;
-    delete m_pFiller;
-    delete m_pFiller2;
-    delete m_pLogo;
-    delete m_pLatestNews;
-    delete m_pVersion;
-    delete m_pMenuArea;
-
-    // Destroy the menu items. Note: The disconnect item isn't always in the
-    // list of menu items (it's only in there when we're in game). This means we
-    // don't delete it when we iterate the list and delete it separately - the
-    // menu item itself still exists even when it's no in the list of menu
-    // items. Perhaps there should be a separate list of loaded items really.
-    for (std::deque<sMenuItem*>::iterator it = m_menuItems.begin(); it != m_menuItems.end(); ++it)
+    auto destroyElement = [this](auto*& element) {
+        if (!element)
+            return;
+        m_pManager->DestroyElementRecursive(element);
+        element = nullptr;
+    };
+
+    for (uint i = 0; i < CORE_MTA_NEWS_ITEMS; ++i)
     {
-        if ((*it) != m_pDisconnect)
+        destroyElement(m_pNewsItemLabels[i]);
+        destroyElement(m_pNewsItemShadowLabels[i]);
+        destroyElement(m_pNewsItemDateLabels[i]);
+        destroyElement(m_pNewsItemNEWLabels[i]);
+    }
+
+    for (sMenuItem* pItem : m_menuItems)
+    {
+        if (!pItem || pItem == m_pDisconnect)
+            continue;
+
+        if (pItem->image)
+        {
+            m_pManager->DestroyElementRecursive(pItem->image);
+            pItem->image = nullptr;
+        }
+
+        delete pItem;
+    }
+    m_menuItems.clear();
+    m_unhoveredItems.clear();
+    m_pHoveredItem = nullptr;
+
+    if (m_pDisconnect)
+    {
+        if (m_pDisconnect->image)
         {
-            delete (*it)->image;
-            delete (*it);
+            m_pManager->DestroyElementRecursive(m_pDisconnect->image);
+            m_pDisconnect->image = nullptr;
         }
+
+        delete m_pDisconnect;
+        m_pDisconnect = nullptr;
     }
 
-    delete m_pDisconnect->image;
-    delete m_pDisconnect;
+    destroyElement(m_pMenuArea);
+    destroyElement(m_pLogo);
+    destroyElement(m_pLatestNews);
+    destroyElement(m_pVersion);
+
+    destroyElement(m_pCanvas);
+    destroyElement(m_pBackground);
+    destroyElement(m_pFiller);
+    destroyElement(m_pFiller2);
+
     delete m_pLanguageSelector;
+    m_pLanguageSelector = nullptr;
+    delete m_pNewsBrowser;
+    m_pNewsBrowser = nullptr;
 }
 
 void CMainMenu::SetMenuVerticalPosition(int iPosY)

Client/core/CMainMenu.cpp

@@ -242,6 +242,7 @@ bool CScreenGrabber::GetBackBufferPixels(uint uiSizeX, uint uiSizeY, CBuffer& bu
     if (!m_pScreenShotTemp)
     {
         strOutError = "No ScreenShotTemp";
+        SAFE_RELEASE(pD3DBackBufferSurface);
         return false;
     }
 
@@ -251,6 +252,7 @@ bool CScreenGrabber::GetBackBufferPixels(uint uiSizeX, uint uiSizeY, CBuffer& bu
     if (FAILED(hr))
     {
         strOutError = SString("StretchRect failed (0x%08x)", hr);
+        SAFE_RELEASE(pD3DBackBufferSurface);
         return false;
     }
 
@@ -260,6 +262,7 @@ bool CScreenGrabber::GetBackBufferPixels(uint uiSizeX, uint uiSizeY, CBuffer& bu
     if (!m_pScreenShotTemp->ReadPixels(buffer, strOutError))
     {
         dassert(!strOutError.empty());
+        SAFE_RELEASE(pD3DBackBufferSurface);
         return false;
     }
 

Client/core/CScreenGrabber.cpp

@@ -10,6 +10,8 @@
  *****************************************************************************/
 
 #include "StdInc.h"
+#include "DXHook/CProxyDirect3DDevice9.h"
+#include <math.h>
 #include <libpng/png.h>
 
 extern CCore* g_pCore;
@@ -38,6 +40,86 @@ static uint    ms_uiHeight = 0;
 // whether we want to actually save photo in documents folder
 static bool savePhotoInDocuments = false;
 
+namespace
+{
+float Clamp(float value, float minValue, float maxValue)
+{
+    if (value < minValue)
+        return minValue;
+    if (value > maxValue)
+        return maxValue;
+    return value;
+}
+
+void ApplyBorderlessAdjustmentsToBuffer(void* rawData, uint width, uint height)
+{
+    if (!rawData || width == 0 || height == 0)
+        return;
+
+    bool isBorderless = false;
+    if (CVideoModeManagerInterface* videoModeManager = GetVideoModeManager())
+        isBorderless = videoModeManager->IsDisplayModeWindowed() || videoModeManager->IsDisplayModeFullScreenWindow();
+
+    if (!isBorderless && ::g_pDeviceState)
+        isBorderless = (::g_pDeviceState->CreationState.PresentationParameters.Windowed != 0);
+
+    float gammaPower = 1.0f;
+    float brightnessScale = 1.0f;
+    float contrastScale = 1.0f;
+    float saturationScale = 1.0f;
+    bool  applyWindowed = true;
+    bool  applyFullscreen = false;
+    ::BorderlessGamma::FetchSettings(gammaPower, brightnessScale, contrastScale, saturationScale, applyWindowed, applyFullscreen);
+
+    const bool adjustmentsEnabled = isBorderless ? applyWindowed : applyFullscreen;
+    if (!adjustmentsEnabled)
+        return;
+
+    if (!::BorderlessGamma::ShouldApplyAdjustments(gammaPower, brightnessScale, contrastScale, saturationScale))
+        return;
+
+    BYTE*       data = static_cast<BYTE*>(rawData);
+    const size_t pixelCount = static_cast<size_t>(width) * static_cast<size_t>(height);
+    const float  inv255 = 1.0f / 255.0f;
+    const float  contrastPivot = 0.5f;
+
+    for (size_t i = 0; i < pixelCount; ++i)
+    {
+        float r = Clamp(data[0] * inv255, 0.0f, 1.0f);
+        float g = Clamp(data[1] * inv255, 0.0f, 1.0f);
+        float b = Clamp(data[2] * inv255, 0.0f, 1.0f);
+
+        r = powf(r, gammaPower);
+        g = powf(g, gammaPower);
+        b = powf(b, gammaPower);
+
+        r *= brightnessScale;
+        g *= brightnessScale;
+        b *= brightnessScale;
+
+        r = (r - contrastPivot) * contrastScale + contrastPivot;
+        g = (g - contrastPivot) * contrastScale + contrastPivot;
+        b = (b - contrastPivot) * contrastScale + contrastPivot;
+
+        float luminance = Clamp(0.299f * r + 0.587f * g + 0.114f * b, 0.0f, 1.0f);
+
+        r = luminance + (r - luminance) * saturationScale;
+        g = luminance + (g - luminance) * saturationScale;
+        b = luminance + (b - luminance) * saturationScale;
+
+        r = Clamp(r, 0.0f, 1.0f);
+        g = Clamp(g, 0.0f, 1.0f);
+        b = Clamp(b, 0.0f, 1.0f);
+
+        data[0] = static_cast<BYTE>(r * 255.0f + 0.5f);
+        data[1] = static_cast<BYTE>(g * 255.0f + 0.5f);
+        data[2] = static_cast<BYTE>(b * 255.0f + 0.5f);
+
+        data += 4;
+    }
+}
+} // namespace
+
 void CScreenShot::InitiateScreenShot(bool bIsCameraShot)
 {
     if (ms_bScreenShot || ms_bIsSaving || IsRateLimited(bIsCameraShot))
@@ -109,6 +191,7 @@ void CScreenShot::CheckForScreenShot(bool bBeforeGUI)
 
         if (uiDataSize == uiReqDataSize)
         {
+            ApplyBorderlessAdjustmentsToBuffer(ms_ScreenShotBuffer.GetData(), ms_uiWidth, ms_uiHeight);
             // Start the save thread
             StartSaveThread();
         }