Merge branch 'master' into setCollide

Author: Proxy-99

Client/core/CCrashDumpWriter.cpp

@@ -11,6 +11,28 @@
 #include "StdInc.h"
 #include "CFileFormat.h"
 #include "CPixelsManager.h"
+#include <CrashTelemetry.h>
+
+namespace
+{
+    const char* PixelsFormatToString(EPixelsFormatType format)
+    {
+        switch (format)
+        {
+            case EPixelsFormat::PLAIN:
+                return "plain";
+            case EPixelsFormat::JPEG:
+                return "jpeg";
+            case EPixelsFormat::PNG:
+                return "png";
+            case EPixelsFormat::DDS:
+                return "dds";
+            case EPixelsFormat::UNKNOWN:
+            default:
+                return "unknown";
+        }
+    }
+}
 
 ///////////////////////////////////////////////////////////////
 // Object creation
@@ -750,6 +772,22 @@ bool CPixelsManager::ChangePixelsFormat(const CPixels& oldPixels, CPixels& newPi
     if (oldFormat == EPixelsFormat::UNKNOWN || newFormat == EPixelsFormat::UNKNOWN)
         return false;
 
+    const uint sourceBytes = oldPixels.GetSize();
+    uint       width = 0;
+    uint       height = 0;
+    GetPixelsSize(oldPixels, width, height);
+
+    SString telemetryDetail;
+    telemetryDetail.Format("%s->%s q=%d bytes=%u dims=%ux%u",
+                           PixelsFormatToString(oldFormat),
+                           PixelsFormatToString(newFormat),
+                           uiQuality,
+                           sourceBytes,
+                           width,
+                           height);
+    // Tag conversions here so crashes show which pixel formats/dimensions were being processed.
+    CrashTelemetry::Scope conversionScope(sourceBytes, oldPixels.GetData(), "Pixels::ChangeFormat", telemetryDetail.c_str());
+
     if (oldFormat == newFormat)
     {
         // No change

Client/core/CrashHandler.cpp

@@ -12,6 +12,7 @@
 #include "gamesa_renderware.h"
 
 #include <map>
+#include <sstream>
 #include <unordered_map>
 #include <unordered_set>
 #include <utility>
@@ -309,9 +310,16 @@ void CRenderWareSA::ModelInfoTXDRemoveTextures(SReplacementTextures* pReplacemen
                 continue;
 
             RwTexture* pOriginalTexture = (idx < perTxdInfo.replacedOriginals.size()) ? perTxdInfo.replacedOriginals[idx] : nullptr;
+            
+            if (pOriginalTexture && !SharedUtil::IsReadablePointer(pOriginalTexture, sizeof(RwTexture)))
+                pOriginalTexture = nullptr;
+                
             swapMap[pOldTexture] = pOriginalTexture;
 
-            if (pOriginalTexture && !RwTexDictionaryContainsTexture(pInfo->pTxd, pOriginalTexture))
+            // Only restore original textures early if this is the last replacement set for this TXD
+            // Otherwise, other replacement sets might still be using the TXD
+            bool isLastReplacement = (pInfo->usedByReplacements.size() == 1);
+            if (pOriginalTexture && isLastReplacement && !RwTexDictionaryContainsTexture(pInfo->pTxd, pOriginalTexture))
                 RwTexDictionaryAddTexture(pInfo->pTxd, pOriginalTexture);
         }
 
@@ -346,6 +354,9 @@ void CRenderWareSA::ModelInfoTXDRemoveTextures(SReplacementTextures* pReplacemen
         {
             if (!pOldTexture)
                 continue;
+            
+            if (!SharedUtil::IsReadablePointer(pOldTexture, sizeof(RwTexture)))
+                continue;
 
             RwTexDictionaryRemoveTexture(pInfo->pTxd, pOldTexture);
             dassert(!RwTexDictionaryContainsTexture(pInfo->pTxd, pOldTexture));
@@ -389,18 +400,85 @@ void CRenderWareSA::ModelInfoTXDRemoveTextures(SReplacementTextures* pReplacemen
         #ifdef MTA_DEBUG
             std::vector<RwTexture*> currentTextures;
             GetTxdTextures(currentTextures, pInfo->pTxd);
-            assert(currentTextures.size() == pInfo->originalTextures.size());
-            for (RwTexture* pOriginalTexture : pInfo->originalTextures)
+            
+            auto formatTextures = [](const std::vector<RwTexture*>& textures) -> std::string {
+                std::ostringstream result;
+                for (size_t i = 0; i < textures.size(); ++i)
+                {
+                    const auto* pTex = textures[i];
+                    const bool isValid = pTex && SharedUtil::IsReadablePointer(pTex, sizeof(RwTexture));
+                    const bool isLast = (i == textures.size() - 1);
+                    
+                    if (isValid)
+                        result << pTex->name << "[0x" << std::hex << pTex << std::dec << "]";
+                    else
+                        result << "INVALID[0x" << std::hex << pTex << std::dec << "]";
+                    
+                    if (!isLast)
+                        result << ", ";
+                }
+                return result.str();
+            };
+            
+            // Allow size mismatch in case texture removal was skipped due to invalid pointers
+            if (currentTextures.size() != pInfo->originalTextures.size())
             {
-                if (!pOriginalTexture)
-                    continue;
-                assert(ListContains(currentTextures, pOriginalTexture));
-                ListRemove(currentTextures, pOriginalTexture);
+                std::ostringstream debugMsg;
+                debugMsg << "TXD " << pInfo->usTxdId << ": texture count mismatch (current=" 
+                         << currentTextures.size() << ", expected=" << pInfo->originalTextures.size() << ")\n";
+                debugMsg << "  Current textures: " << formatTextures(currentTextures);
+                debugMsg << "\n  Expected textures: " << formatTextures(pInfo->originalTextures);
+                debugMsg << "\n";
+                OutputDebugString(debugMsg.str().c_str());
+            }
+            else
+            {
+                // First pass: validate all original textures are present
+                for (const auto* pOriginalTexture : pInfo->originalTextures)
+                {
+                    if (!pOriginalTexture)
+                        continue;
+                    if (!ListContains(currentTextures, pOriginalTexture))
+                    {
+                        const char* texName = SharedUtil::IsReadablePointer(pOriginalTexture, sizeof(RwTexture)) 
+                            ? pOriginalTexture->name : "INVALID";
+                        std::ostringstream oss;
+                        oss << "Original texture not found in TXD " << pInfo->usTxdId 
+                            << " - texture '" << texName << "' [0x" << std::hex << pOriginalTexture << std::dec 
+                            << "] was removed or replaced unexpectedly";
+                        const std::string assertMsg = oss.str();
+                        assert(false && assertMsg.c_str());
+                    }
+                }
+                
+                // Second pass: remove original textures from current list to find extras
+                for (auto* pOriginalTexture : pInfo->originalTextures)
+                {
+                    if (pOriginalTexture)
+                        ListRemove(currentTextures, pOriginalTexture);
+                }
+                
+                // Check for leaked textures
+                if (!currentTextures.empty())
+                {
+                    std::ostringstream oss;
+                    oss << "Extra textures remain in TXD " << pInfo->usTxdId 
+                        << " after removing all originals - indicates texture leak. Remaining: "
+                        << formatTextures(currentTextures);
+                    const std::string assertMsg = oss.str();
+                    assert(false && assertMsg.c_str());
+                }
             }
-            assert(currentTextures.empty());
 
-            int32_t refsCount = CTxdStore_GetNumRefs(pInfo->usTxdId);
-            assert(refsCount > 0 && "Should have at least one TXD reference here");
+            const int32_t refsCount = CTxdStore_GetNumRefs(pInfo->usTxdId);
+            if (refsCount <= 0)
+            {
+                std::ostringstream oss;
+                oss << "TXD " << pInfo->usTxdId << " has invalid ref count " 
+                    << refsCount << " - should be > 0 before cleanup";
+                const std::string assertMsg = oss.str();
+                assert(false && assertMsg.c_str());
+            }
         #endif
             // Clear original textures to prevent dangling pointers after TXD ref removal
             // The textures themselves are owned by the TXD and will be cleaned up when ref count hits zero

Client/core/Graphics/CPixelsManager.cpp

@@ -755,9 +755,16 @@ short CRenderWareSA::CTxdStore_GetTxdRefcount(unsigned short usTxdID)
 
 bool CRenderWareSA::RwTexDictionaryContainsTexture(RwTexDictionary* pTXD, RwTexture* pTex)
 {
-    // Avoid crashes with freed/invalid textures
+    // Avoid crashes with freed/invalid textures and TXDs
     if (!pTex || !pTXD)
         return false;
+
+    // Prevent crash when texture/TXD has been freed but pointer still exists
+    if (!SharedUtil::IsReadablePointer(pTex, sizeof(RwTexture)))
+        return false;
+    
+    if (!SharedUtil::IsReadablePointer(pTXD, sizeof(RwTexDictionary)))
+        return false;
 
     return pTex->txd == pTXD;
 }

Client/game_sa/CRenderWareSA.TextureReplacing.cpp

@@ -340,8 +340,16 @@ void CStreamingSA::SetStreamingInfo(uint modelid, unsigned char usStreamID, uint
     // In this case, we must force-remove the RwObject from memory, because it is no longer used,
     // and due to the archive change the streamer no longer detects it and therefore won't delete it.
     // As a result, a memory leak occurs after every call to engineImageLinkDFF.
-    if (CModelInfo* modelInfo = g_pCore->GetGame()->GetModelInfo(modelid); modelInfo->GetRwObject())
-        RemoveModel(modelid);
+    const auto baseTxdId = g_pCore->GetGame()->GetBaseIDforTXD();
+    if (modelid < static_cast<uint>(baseTxdId))
+    {
+        if (CModelInfo* modelInfo = g_pCore->GetGame()->GetModelInfo(modelid, true))
+        {
+            // Only DFF models got RwObjects, TXDs don't, so we only flush those here (or crash)
+            if (modelInfo->GetRwObject())
+                RemoveModel(modelid);
+        }
+    }
 
     // Change nextInImg field for prev model
     for (CStreamingInfo& info : ms_aInfoForModel)

Client/game_sa/CRenderWareSA.cpp

@@ -4,6 +4,7 @@
 #define MTA_CLIENT
 #define SHARED_UTIL_WITH_FAST_HASH_MAP
 #include "SharedUtil.h"
+#include <CrashTelemetry.h>
 
 #include <string.h>
 #include <stdio.h>

Client/game_sa/CStreamingSA.cpp

@@ -747,6 +747,14 @@ bool CClientEntity::CallEvent(const char* szName, const CLuaArguments& Arguments
     if (!g_pClientGame->GetDebugHookManager()->OnPreEvent(szName, Arguments, this, NULL))
         return false;
 
+    const SString& thisTypeName = GetTypeName();
+    const char* thisTypeNameCStr = !thisTypeName.empty() ? thisTypeName.c_str() : "<unknown>";
+    const ElementID thisId = GetID();
+    SString telemetryDetail;
+    telemetryDetail.Format("%s %s(%u)", szName, thisTypeNameCStr, thisId.Value());
+    // Capture the element+event context so any crash (even core.dll faults) reports the last event being dispatched.
+    CrashTelemetry::Scope entityScope(0, this, "Entity::CallEvent", telemetryDetail.c_str());
+
     TIMEUS startTime = GetTimeUs();
 
     CEvents* pEvents = g_pClientGame->GetEvents();

Client/mods/deathmatch/StdInc.h

@@ -187,6 +187,32 @@ bool CMapEventManager::Call(const char* szName, const CLuaArguments& Arguments,
                     if (!g_pClientGame->GetDebugHookManager()->OnPreEventFunction(szName, Arguments, pSource, nullptr, pMapEvent))
                         continue;
 
+                    const char* scriptName = pMapEvent->GetVM()->GetScriptName();
+                    CResource*  pEventResource = pMapEvent->GetVM()->GetResource();
+                    const char* resourceName = pEventResource ? pEventResource->GetName() : "<no-resource>";
+
+                    SString sourceTag = "<null>";
+                    if (pSource)
+                    {
+                        const SString& sourceTypeName = pSource->GetTypeName();
+                        const char* sourceTypeNameCStr = !sourceTypeName.empty() ? sourceTypeName.c_str() : "<unknown>";
+                        sourceTag.Format("%s(%u)", sourceTypeNameCStr, pSource->GetID().Value());
+                    }
+
+                    SString thisTag = "<null>";
+                    if (pThis)
+                    {
+                        const SString& thisTypeName = pThis->GetTypeName();
+                        const char* thisTypeNameCStr = !thisTypeName.empty() ? thisTypeName.c_str() : "<unknown>";
+                        thisTag.Format("%s(%u)", thisTypeNameCStr, pThis->GetID().Value());
+                    }
+
+                    SString telemetryDetail;
+                    telemetryDetail.Format("%s::%s src=%s this=%s", scriptName, resourceName, sourceTag.c_str(), thisTag.c_str());
+                    // Tag each Lua event dispatch so crash dumps show which
+                    // resource/event/element executed last
+                    CrashTelemetry::Scope eventScope(0, pThis, "LuaEvent::Call", telemetryDetail.c_str());
+
                     // Store the current values of the globals
                     lua_getglobal(pState, "source");
                     CLuaArgument OldSource(pState, -1);

Client/mods/deathmatch/logic/CClientEntity.cpp

@@ -202,6 +202,9 @@ bool CLuaArguments::Call(CLuaMain* pLuaMain, const CLuaFunctionRef& iLuaFunction
     assert(pLuaMain);
     TIMEUS startTime = GetTimeUs();
 
+    const SString& functionTag = pLuaMain->GetFunctionTag(iLuaFunction.ToInt());
+    CrashTelemetry::Scope telemetryScope(0, pLuaMain, "Lua::Call", functionTag.c_str());
+
     // Add the function name to the stack and get the event from the table
     lua_State* luaVM = pLuaMain->GetVirtualMachine();
     assert(luaVM);
@@ -244,7 +247,7 @@ bool CLuaArguments::Call(CLuaMain* pLuaMain, const CLuaFunctionRef& iLuaFunction
             lua_pop(luaVM, 1);
     }
 
-    CClientPerfStatLuaTiming::GetSingleton()->UpdateLuaTiming(pLuaMain, pLuaMain->GetFunctionTag(iLuaFunction.ToInt()), GetTimeUs() - startTime);
+    CClientPerfStatLuaTiming::GetSingleton()->UpdateLuaTiming(pLuaMain, functionTag, GetTimeUs() - startTime);
     return true;
 }
 
@@ -254,6 +257,8 @@ bool CLuaArguments::CallGlobal(CLuaMain* pLuaMain, const char* szFunction, CLuaA
     assert(szFunction);
     TIMEUS startTime = GetTimeUs();
 
+    CrashTelemetry::Scope telemetryScope(0, pLuaMain, "Lua::CallGlobal", szFunction);
+
     // Add the function name to the stack and get the event from the table
     lua_State* luaVM = pLuaMain->GetVirtualMachine();
     assert(luaVM);