Merge branch 'master' into fix-chat-delay-high-player-count

Author: Zephkek

Client/core/Graphics/CGraphics.cpp

@@ -27,6 +27,40 @@ extern std::atomic<bool> g_bInMTAScene;
 
 using namespace std;
 
+namespace
+{
+    // Convert a straight-alpha ARGB tint into its premultiplied form:
+    //
+    //     (R, G, B, A)  ->  (R*A/255, G*A/255, B*A/255, A)
+    //
+    // Needed when routing a translucent draw onto the (ONE, INVSRCALPHA)
+    // pipeline. That pipeline computes
+    //
+    //     out.rgb = src.rgb + dst.rgb * (1 - src.a)
+    //
+    // with src.rgb = tex.rgb * diff.rgb and src.a = tex.a * diff.a, so
+    // diff.a never enters the source rgb term. For a PM texel tex.rgb =
+    // R*A_tex, that leaves
+    //
+    //     out.rgb = R * A_tex * diff.rgb + dst.rgb * (1 - A_tex * diff.a)
+    //
+    // which is brighter than the correct PM composite by a factor of
+    // 1/diff.a during a fade. Premultiplying the diffuse here
+    // (diff.rgb *= diff.a) restores the missing factor and the equation
+    // reduces exactly to the PM "over" operator.
+    inline SColor PremultiplyAlpha(SColor c) noexcept
+    {
+        if (c.A == 0xFF)
+            return c;
+
+        const uint a = c.A;
+        c.R = static_cast<unsigned char>((c.R * a + 127) / 255);
+        c.G = static_cast<unsigned char>((c.G * a + 127) / 255);
+        c.B = static_cast<unsigned char>((c.B * a + 127) / 255);
+        return c;
+    }
+}  // namespace
+
 template <>
 CGraphics* CSingleton<CGraphics>::m_pSingleton = NULL;
 
@@ -1080,6 +1114,15 @@ void CGraphics::DrawMaterialPrimitiveQueued(std::vector<PrimitiveMaterialVertice
     sDrawQueueItem Item;
     Item.eType = QUEUE_PRIMITIVEMATERIAL;
     Item.blendMode = m_ActiveBlendMode;
+    // Same PM auto-route as DrawTextureQueued, so dxDrawMaterialPrimitive
+    // composites SVG (premultiplied) textures correctly under default blend.
+    if (Item.blendMode == EBlendMode::BLEND && pMaterial && pMaterial->m_bPremultipliedAlpha)
+    {
+        Item.blendMode = EBlendMode::ADD;
+        // See PremultiplyAlpha for the diffuse premultiply rationale (#3828).
+        for (auto& vert : *pVecVertices)
+            vert.Color = PremultiplyAlpha(vert.Color);
+    }
     Item.PrimitiveMaterial.eType = eType;
     Item.PrimitiveMaterial.pMaterial = pMaterial;
     Item.PrimitiveMaterial.pVecVertices = pVecVertices;
@@ -1134,6 +1177,16 @@ void CGraphics::DrawTextureQueued(float fX, float fY, float fWidth, float fHeigh
     // Set up a queue item
     sDrawQueueItem Item;
     Item.blendMode = m_ActiveBlendMode;
+    // Premultiplied-alpha textures (SVG) need the (ONE, INVSRCALPHA) pipeline,
+    // not the straight-alpha BLEND mode. Route the default blend to ADD when
+    // the script hasn't asked for a specific mode (issue #4891), and convert
+    // the diffuse tint to PM so a translucent dxDrawImage call still fades
+    // correctly through that pipeline (issue #3828).
+    if (Item.blendMode == EBlendMode::BLEND && pMaterial && pMaterial->m_bPremultipliedAlpha)
+    {
+        Item.blendMode = EBlendMode::ADD;
+        ulColor = PremultiplyAlpha(ulColor);
+    }
     Item.Texture.fX = fX;
     Item.Texture.fY = fY;
     Item.Texture.fWidth = fWidth;

Client/core/Graphics/CRenderItem.VectorGraphic.cpp

@@ -24,6 +24,9 @@ void CVectorGraphicItem::PostConstruct(CRenderItemManager* pManager, uint width,
     m_uiSizeY = height;
     m_uiSurfaceSizeX = width;
     m_uiSurfaceSizeY = height;
+    // lunasvg writes premultiplied ARGB into the surface; let the draw
+    // path use a PM-aware blend instead of unpremultiplying per pixel.
+    m_bPremultipliedAlpha = true;
 
     CreateUnderlyingData();
 }

Client/game_sa/CVehicleSA.cpp

@@ -11,6 +11,7 @@
 
 #include "StdInc.h"
 #include <core/CCoreInterface.h>
+#include <game/CAESoundManager.h>
 #include <multiplayer/CMultiplayer.h>
 #include "CAutomobileSA.h"
 #include "CBikeSA.h"
@@ -145,8 +146,29 @@ static void __declspec(naked) HOOK_CPlane_ProcessFlyingCarStuff()
     // clang-format on
 }
 
+#define NUM_FirstStreamEngineSlot    7
+#define NUM_LastStreamEngineSlot     16
+#define NUM_AllSoundIndices          0xFFFFFFFF
+#define NUM_ResidentEngineSlot       40
+#define NUM_LocalVehicleAudioContext 0x0
+#define VAR_VehicleAudioContext      0x50230C
+
 namespace
 {
+    void CancelVehicleAudioSlots(CAEVehicleAudioEntitySAInterface* pAudioInterface)
+    {
+        auto* pSoundManager = pGame ? pGame->GetAESoundManager() : nullptr;
+        if (!pAudioInterface || !pSoundManager)
+            return;
+
+        if (pAudioInterface->m_wEngineBankSlotId >= NUM_FirstStreamEngineSlot && pAudioInterface->m_wEngineBankSlotId <= NUM_LastStreamEngineSlot)
+            pSoundManager->CancelSoundsInBankSlot(pAudioInterface->m_wEngineBankSlotId, NUM_AllSoundIndices);
+
+        if (pAudioInterface->m_bPlayerDriver || pAudioInterface->m_bPlayerPassenger ||
+            *reinterpret_cast<const BYTE*>(VAR_VehicleAudioContext) == NUM_LocalVehicleAudioContext)
+            pSoundManager->CancelSoundsInBankSlot(NUM_ResidentEngineSlot, NUM_AllSoundIndices);
+    }
+
     bool ClumpDumpCB(RpAtomic* pAtomic, void* data)
     {
         CVehicleSA* pVehicleSA = (CVehicleSA*)data;
@@ -2582,7 +2604,14 @@ bool CVehicleSA::SetWindowOpenFlagState(unsigned char ucWindow, bool bState)
 
 void CVehicleSA::ReinitAudio()
 {
+    if (!m_pVehicleAudioEntity)
+        return;
+
     auto* audioInterface = m_pVehicleAudioEntity->GetInterface();
+    if (!audioInterface)
+        return;
+
+    CancelVehicleAudioSlots(audioInterface);
 
     audioInterface->TerminateAudio();
     audioInterface->InitAudio(GetVehicleInterface());

Client/game_sa/CWeatherSA.cpp

@@ -25,6 +25,22 @@ void CWeatherSA::Set(unsigned char primary, unsigned char secondary)
     MemPutFast<unsigned char>(0xC8131C, secondary);  // CWeather::NewWeatherType
 }
 
+void CWeatherSA::ResyncInterpolationWithGameClock(unsigned char primary, unsigned char secondary)
+{
+    // CWeather::InterpolationValue — see plugin_sa CWeather.cpp (0xC8130C)
+    constexpr DWORD VAR_InterpolationValue = 0xC8130C;
+    constexpr DWORD VAR_TimeMinutes = 0xB70152;
+
+    if (primary == secondary)
+        MemPutFast<float>(VAR_InterpolationValue, 0.0f);
+    else
+    {
+        const auto  ucMinute = *reinterpret_cast<unsigned char*>(VAR_TimeMinutes);
+        const float fInterp = std::min(1.f, static_cast<float>(ucMinute) / 60.f);
+        MemPutFast<float>(VAR_InterpolationValue, fInterp);
+    }
+}
+
 void CWeatherSA::Release()
 {
     MemPutFast<unsigned char>(0xC81318, 0xFF);  // CWeather::ForcedWeatherType

Client/game_sa/CWeatherSA.h

@@ -20,6 +20,7 @@ class CWeatherSA : public CWeather
 public:
     unsigned char Get();
     void          Set(unsigned char primary, unsigned char secondary);
+    void          ResyncInterpolationWithGameClock(unsigned char primary, unsigned char secondary);
 
     void Release();
 

Client/mods/deathmatch/logic/CBlendedWeather.cpp

@@ -53,8 +53,14 @@ void CBlendedWeather::DoPulse()
         }
     }
 
-    // Force the weather
-    m_pWeather->Set(static_cast<unsigned char>(m_ucPrimaryWeather), static_cast<unsigned char>(m_ucSecondaryWeather));
+    const auto ucPrimary = static_cast<unsigned char>(m_ucPrimaryWeather);
+    const auto ucSecondary = static_cast<unsigned char>(m_ucSecondaryWeather);
+
+    m_pWeather->Set(ucPrimary, ucSecondary);
+    // CWeather::Update (before this pulse) advances InterpolationValue for its own Old/New pair.
+    // After we overwrite Old/New with MTA's state, keep the blend weight aligned with the game
+    // clock so reflective/translucent materials (e.g. glass windows) match the sky (#4803).
+    m_pWeather->ResyncInterpolationWithGameClock(ucPrimary, ucSecondary);
 }
 
 void CBlendedWeather::SetWeather(unsigned char ucWeather)

Client/mods/deathmatch/logic/CClientGame.cpp

@@ -285,6 +285,7 @@ CClientGame::CClientGame(bool bLocalPlay) : m_ServerInfo(new CServerInfo())
     g_pMultiplayer->SetRenderHeliLightHandler(CClientGame::StaticRenderHeliLightHandler);
     g_pMultiplayer->SetRenderEverythingBarRoadsHandler(CClientGame::StaticRenderEverythingBarRoadsHandler);
     g_pMultiplayer->SetChokingHandler(CClientGame::StaticChokingHandler);
+    g_pMultiplayer->SetPreWeatherUpdateHandler(CClientGame::StaticPreWeatherUpdateHandler);
     g_pMultiplayer->SetPreWorldProcessHandler(CClientGame::StaticPreWorldProcessHandler);
     g_pMultiplayer->SetPostWorldProcessHandler(CClientGame::StaticPostWorldProcessHandler);
     g_pMultiplayer->SetPostWorldProcessPedsAfterPreRenderHandler(CClientGame::StaticPostWorldProcessPedsAfterPreRenderHandler);
@@ -494,6 +495,7 @@ CClientGame::~CClientGame()
     g_pMultiplayer->SetRenderHeliLightHandler(nullptr);
     g_pMultiplayer->SetRenderEverythingBarRoadsHandler(nullptr);
     g_pMultiplayer->SetChokingHandler(NULL);
+    g_pMultiplayer->SetPreWeatherUpdateHandler(NULL);
     g_pMultiplayer->SetPreWorldProcessHandler(NULL);
     g_pMultiplayer->SetPostWorldProcessHandler(NULL);
     g_pMultiplayer->SetPostWorldProcessPedsAfterPreRenderHandler(nullptr);
@@ -3629,6 +3631,11 @@ bool CClientGame::StaticBlendAnimationHierarchyHandler(CAnimBlendAssociationSAIn
     return g_pClientGame->BlendAnimationHierarchyHandler(pAnimAssoc, pOutAnimHierarchy, pFlags, pClump);
 }
 
+void CClientGame::StaticPreWeatherUpdateHandler()
+{
+    g_pClientGame->PreWeatherUpdateHandler();
+}
+
 void CClientGame::StaticPreWorldProcessHandler()
 {
     g_pClientGame->PreWorldProcessHandler();
@@ -3900,6 +3907,20 @@ void CClientGame::PreRenderSkyHandler()
     g_pCore->GetGraphics()->GetRenderItemManager()->PreDrawWorld();
 }
 
+void CClientGame::PreWeatherUpdateHandler()
+{
+    // Fix #4803 (building light flicker): Re-apply MTA's weather state BEFORE
+    // CWeather::Update runs. CWeather::Update detects a clock wrap when setTime()
+    // jumps the game clock past InterpolationValue and re-derives Rain, Foggyness,
+    // CloudCoverage, ExtraSunnyness, SunGlare, HeatHaze, etc. from a freshly-picked
+    // weather pair. Those globals drive cloud, fog and night-time building light
+    // rendering for the rest of the frame, and PreWorldProcessHandler runs too late
+    // to undo the damage. Pre-syncing Old/New/InterpolationValue here keeps the
+    // wrap branch from firing.
+    if (m_pManager->IsGameLoaded() && m_pBlendedWeather)
+        m_pBlendedWeather->DoPulse();
+}
+
 void CClientGame::PreWorldProcessHandler()
 {
     // Fix #4803: Re-apply MTA's weather state before CTimeCycle::CalcColoursForPoint()

Client/mods/deathmatch/logic/CClientGame.h

@@ -577,6 +577,7 @@ class CClientGame
     static void                              StaticRenderHeliLightHandler();
     static void                              StaticRenderEverythingBarRoadsHandler();
     static bool                              StaticChokingHandler(unsigned char ucWeaponType);
+    static void                              StaticPreWeatherUpdateHandler();
     static void                              StaticPreWorldProcessHandler();
     static void                              StaticPostWorldProcessHandler();
     static void                              StaticPostWorldProcessPedsAfterPreRenderHandler();
@@ -626,6 +627,7 @@ class CClientGame
     void                              Render3DStuffHandler();
     void                              PreRenderSkyHandler();
     bool                              ChokingHandler(unsigned char ucWeaponType);
+    void                              PreWeatherUpdateHandler();
     void                              PreWorldProcessHandler();
     void                              PostWorldProcessHandler();
     void                              PostWorldProcessPedsAfterPreRenderHandler();

Client/mods/deathmatch/logic/CClientVectorGraphicDisplay.cpp

@@ -56,37 +56,6 @@ void CClientVectorGraphicDisplay::Render()
     }
 }
 
-void CClientVectorGraphicDisplay::UnpremultiplyBitmap(Bitmap& bitmap)
-{
-    auto width = bitmap.width();
-    auto height = bitmap.height();
-    auto stride = bitmap.stride();
-    auto rowData = bitmap.data();
-
-    for (decltype(height) y = 0; y < height; y++)
-    {
-        auto data = rowData;
-        for (decltype(width) x = 0; x < width; x++)
-        {
-            auto& b = data[0];
-            auto& g = data[1];
-            auto& r = data[2];
-            auto& a = data[3];
-
-            if (a != 0)
-            {
-                r = (r * 255) / a;
-                g = (g * 255) / a;
-                b = (b * 255) / a;
-            }
-
-            data += 4;
-        }
-
-        rowData += stride;
-    }
-}
-
 void CClientVectorGraphicDisplay::UpdateTexture()
 {
     if (!m_pVectorGraphic || m_pVectorGraphic->IsDestroyed())
@@ -144,7 +113,10 @@ void CClientVectorGraphicDisplay::UpdateTexture()
             return;
         }
 
-        UnpremultiplyBitmap(bitmap);
+        // The surface stays in lunasvg's native premultiplied ARGB layout.
+        // CGraphics::DrawTextureQueued routes the draw to a PM blend so we
+        // avoid the precision loss caused by an integer unpremultiply
+        // (see issue #4891 banding on translucent SVG gradients).
 
         // Unlock surface
         surface->UnlockRect();

Client/mods/deathmatch/logic/CClientVectorGraphicDisplay.h

@@ -36,8 +36,6 @@ class CClientVectorGraphicDisplay final : public CClientDisplay
     void Update();
 
 private:
-    void UnpremultiplyBitmap(lunasvg::Bitmap& bitmap);
-
     CClientVectorGraphic* m_pVectorGraphic;
 
     bool m_bIsCleared;