Synchronize changes from 1.6 branch [ci skip]

3640a2e Addendum #2 to vertex buffer lock fixes;
6f3369b Addendum to vertex buffer lock fixes (Return S_OK as GTA expects for return values)

Author: github-actions[bot]

Client/core/DXHook/CProxyDirect3DVertexBuffer.cpp

@@ -13,6 +13,8 @@
 #include "CProxyDirect3DVertexBuffer.h"
 #include "CAdditionalVertexStreamManager.h"
 #include "CVertexStreamBoundingBoxManager.h"
+#include <algorithm>
+#include <cstring>
 
 /////////////////////////////////////////////////////////////
 //
@@ -30,6 +32,11 @@ CProxyDirect3DVertexBuffer::CProxyDirect3DVertexBuffer(IDirect3DDevice9* InD3DDe
     m_dwUsage = Usage;
     m_dwFVF = FVF;
     m_pool = Pool;
+    m_bFallbackActive = false;
+    m_fallbackOffset = 0;
+    m_fallbackSize = 0;
+    m_fallbackFlags = 0;
+    m_fallbackStorage.clear();
 
     m_stats.iCurrentCount++;
     m_stats.iCurrentBytes += m_iMemUsed;
@@ -113,42 +120,196 @@ HRESULT CProxyDirect3DVertexBuffer::Lock(UINT OffsetToLock, UINT SizeToLock, voi
             pBoundingBoxManager->OnVertexBufferRangeInvalidated(m_pOriginal, OffsetToLock, SizeToLock);
     }
 
+    if (m_bFallbackActive)
+    {
+        m_bFallbackActive = false;
+        m_fallbackOffset = 0;
+        m_fallbackSize = 0;
+        m_fallbackFlags = 0;
+    }
+
     *ppbData = nullptr;
     HRESULT hr = DoLock(OffsetToLock, SizeToLock, ppbData, Flags);
     HRESULT originalHr = hr;
 
-    if (SUCCEEDED(hr) && *ppbData == nullptr)
+    bool  bPointerNullEvent = SUCCEEDED(hr) && (*ppbData == nullptr);
+    bool  bRetryAttempted = false;
+    bool  bRetrySucceeded = false;
+    bool  bFallbackUsed = false;
+    bool  bUnlockedAfterNull = false;
+    DWORD retryFlags = Flags;
+
+    if (bPointerNullEvent)
     {
-        hr = D3DERR_INVALIDCALL;
+        WriteDebugEvent(SString("Lock VertexBuffer: initial pointer null (Usage:%08x Flags:%08x Offset:%x Size:%x)", m_dwUsage, Flags, OffsetToLock,
+                                 SizeToLock));
+
+        // Retry once for dynamic buffers using DISCARD
+        if ((m_dwUsage & D3DUSAGE_DYNAMIC) && (Flags & D3DLOCK_READONLY) == 0)
+        {
+            bRetryAttempted = true;
+
+            retryFlags &= ~(DWORD)(D3DLOCK_NOOVERWRITE | D3DLOCK_DISCARD | D3DLOCK_READONLY);
+            retryFlags |= D3DLOCK_DISCARD;
+
+            // Release the bogus lock result before retrying
+            m_pOriginal->Unlock();
+            bUnlockedAfterNull = true;
+
+            void* pRetryData = nullptr;
+            hr = DoLock(OffsetToLock, SizeToLock, &pRetryData, retryFlags);
+
+            if (SUCCEEDED(hr) && pRetryData != nullptr)
+            {
+                *ppbData = pRetryData;
+                bPointerNullEvent = false;
+                bRetrySucceeded = true;
+                WriteDebugEvent(SString("Lock VertexBuffer: retry with DISCARD succeeded (Flags:%08x)", retryFlags));
+            }
+            else
+            {
+                // Ensure we unlock on success with null pointer to avoid leaving the resource locked
+                if (SUCCEEDED(hr))
+                {
+                    m_pOriginal->Unlock();
+                    bUnlockedAfterNull = true;
+                }
+            }
+        }
+
+        if (bPointerNullEvent)
+        {
+            if (!bUnlockedAfterNull && SUCCEEDED(hr))
+            {
+                m_pOriginal->Unlock();
+                bUnlockedAfterNull = true;
+            }
+            // Fall back to artificial buffer
+            UINT clampedOffset = std::min(OffsetToLock, m_iMemUsed);
+            UINT clampedSize = SizeToLock;
+            if (clampedOffset + clampedSize > m_iMemUsed)
+                clampedSize = m_iMemUsed - clampedOffset;
+            if (clampedSize == 0 && clampedOffset < m_iMemUsed)
+                clampedSize = m_iMemUsed - clampedOffset;
+
+            // Ensure we have some storage to hand back (even zero-sized locks receive a valid pointer)
+            size_t requiredStorage = std::max<size_t>(static_cast<size_t>(clampedSize), static_cast<size_t>(1));
+            if (m_fallbackStorage.size() < requiredStorage)
+                m_fallbackStorage.resize(requiredStorage);
+
+            if (clampedSize > 0 && (Flags & D3DLOCK_READONLY))
+                memset(m_fallbackStorage.data(), 0, clampedSize);
+
+            *ppbData = m_fallbackStorage.data();
+
+            m_bFallbackActive = true;
+            m_fallbackOffset = clampedOffset;
+            m_fallbackSize = clampedSize;
+            m_fallbackFlags = Flags;
+
+            bFallbackUsed = true;
+            bPointerNullEvent = true;
+
+            hr = D3D_OK;
+
+            WriteDebugEvent(SString("Lock VertexBuffer: engaged fallback buffer (Offset:%x Size:%x Flags:%08x)", m_fallbackOffset, m_fallbackSize,
+                                     m_fallbackFlags));
+        }
     }
 
     // Report problems
-    if (FAILED(hr))
+    if (FAILED(hr) || bPointerNullEvent)
     {
         struct
         {
             const char* szText;
             uint        uiReportId;
             uint        uiLogEventId;
         } info;
-        if (hr == D3DERR_INVALIDCALL && originalHr == D3D_OK)
+        HRESULT reportHr = FAILED(hr) ? hr : D3DERR_INVALIDCALL;
+        if (bPointerNullEvent && originalHr == D3D_OK)
             info = {"result NULL", 8621, 621};
-        else if (hr == STATUS_ARRAY_BOUNDS_EXCEEDED)
+        else if (reportHr == STATUS_ARRAY_BOUNDS_EXCEEDED)
             info = {"offset out of range", 8622, 622};
-        else if (hr == STATUS_ACCESS_VIOLATION)
+        else if (reportHr == STATUS_ACCESS_VIOLATION)
             info = {"access violation", 8623, 623};
         else
             info = {"fail", 8620, 620};
 
-        SString strMessage("Lock VertexBuffer [%s] hr:%x origHr:%x Length:%x Usage:%x FVF:%x Pool:%x OffsetToLock:%x SizeToLock:%x Flags:%x", info.szText, hr,
-                           originalHr, m_iMemUsed, m_dwUsage, m_dwFVF, m_pool, OffsetToLock, SizeToLock, Flags);
+        SString strMessage(
+            "Lock VertexBuffer [%s] hr:%x origHr:%x returnHr:%x pointerNull:%u retryAttempted:%u retrySucceeded:%u fallback:%u fallbackSize:%x fallbackFlags:%x"
+            " unlockedAfterNull:%u Length:%x Usage:%x FVF:%x Pool:%x OffsetToLock:%x SizeToLock:%x Flags:%x retryFlags:%x",
+            info.szText, reportHr, originalHr, hr, static_cast<uint>(bPointerNullEvent), static_cast<uint>(bRetryAttempted),
+            static_cast<uint>(bRetrySucceeded), static_cast<uint>(bFallbackUsed), m_fallbackSize, m_fallbackFlags, static_cast<uint>(bUnlockedAfterNull),
+            m_iMemUsed, m_dwUsage, m_dwFVF, m_pool, OffsetToLock, SizeToLock, Flags, retryFlags);
         WriteDebugEvent(strMessage);
         AddReportLog(info.uiReportId, strMessage);
         CCore::GetSingleton().LogEvent(info.uiLogEventId, "Lock VertexBuffer", "", strMessage);
     }
     return hr;
 }
 
+/////////////////////////////////////////////////////////////
+//
+// CProxyDirect3DVertexBuffer::Unlock
+//
+// Apply fallback data if we had to hand out an artificial buffer
+//
+/////////////////////////////////////////////////////////////
+HRESULT CProxyDirect3DVertexBuffer::Unlock()
+{
+    if (!m_bFallbackActive)
+        return m_pOriginal->Unlock();
+
+    HRESULT copyResult = D3D_OK;
+
+    if ((m_fallbackFlags & D3DLOCK_READONLY) == 0 && m_fallbackSize > 0)
+    {
+        UINT offset = std::min(m_fallbackOffset, m_iMemUsed);
+        UINT size = m_fallbackSize;
+        if (offset + size > m_iMemUsed)
+            size = (offset < m_iMemUsed) ? (m_iMemUsed - offset) : 0;
+
+        if (size > 0)
+        {
+            DWORD writeFlags = m_fallbackFlags;
+            writeFlags &= ~(DWORD)(D3DLOCK_NOOVERWRITE | D3DLOCK_READONLY);
+            if (m_dwUsage & D3DUSAGE_DYNAMIC)
+                writeFlags |= D3DLOCK_DISCARD;
+
+            void*   pReal = nullptr;
+            HRESULT lockHr = DoLock(offset, size, &pReal, writeFlags);
+
+            if (SUCCEEDED(lockHr) && pReal != nullptr)
+            {
+                memcpy(pReal, m_fallbackStorage.data(), size);
+                HRESULT unlockHr = m_pOriginal->Unlock();
+                if (FAILED(unlockHr))
+                    copyResult = unlockHr;
+            }
+            else
+            {
+                if (SUCCEEDED(lockHr))
+                    m_pOriginal->Unlock();
+
+                WriteDebugEvent(SString("Unlock VertexBuffer: failed to copy fallback data (lockHr:%x offset:%x size:%x flags:%08x)", lockHr, offset, size,
+                                           writeFlags));
+                copyResult = FAILED(lockHr) ? lockHr : D3DERR_INVALIDCALL;
+            }
+        }
+    }
+
+    WriteDebugEvent(SString("Unlock VertexBuffer: fallback completed (offset:%x size:%x flags:%08x result:%x)", m_fallbackOffset, m_fallbackSize,
+                             m_fallbackFlags, copyResult));
+
+    m_bFallbackActive = false;
+    m_fallbackOffset = 0;
+    m_fallbackSize = 0;
+    m_fallbackFlags = 0;
+
+    return copyResult;
+}
+
 /////////////////////////////////////////////////////////////
 //
 // CProxyDirect3DVertexBuffer::DoLock

Client/core/DXHook/CProxyDirect3DVertexBuffer.h

@@ -12,6 +12,8 @@
 #pragma once
 
 #include <d3d9.h>
+#include <cstdint>
+#include <vector>
 #include "CProxyDirect3DDevice9.h"  // Include full definition for SResourceMemory
 
 DEFINE_GUID(CProxyDirect3DVertexBuffer_GUID, 0x128A025E, 0x0100, 0x04F1, 0x40, 0x60, 0x53, 0x19, 0x44, 0x56, 0x59, 0x42);
@@ -39,7 +41,7 @@ class CProxyDirect3DVertexBuffer : public IDirect3DVertexBuffer9
 
     /*** IDirect3DVertexBuffer9 methods ***/
     HRESULT __stdcall Lock(UINT OffsetToLock, UINT SizeToLock, void** ppbData, DWORD Flags);
-    HRESULT __stdcall Unlock() { return m_pOriginal->Unlock(); }
+    HRESULT __stdcall Unlock();
     HRESULT __stdcall GetDesc(D3DVERTEXBUFFER_DESC* pDesc) { return m_pOriginal->GetDesc(pDesc); }
 
     // CProxyDirect3DVertexBuffer
@@ -56,4 +58,10 @@ class CProxyDirect3DVertexBuffer : public IDirect3DVertexBuffer9
     DWORD                                   m_dwFVF;
     D3DPOOL                                 m_pool;
     CProxyDirect3DDevice9::SResourceMemory& m_stats;
+
+    bool                 m_bFallbackActive;
+    UINT                 m_fallbackOffset;
+    UINT                 m_fallbackSize;
+    DWORD                m_fallbackFlags;
+    std::vector<uint8_t> m_fallbackStorage;
 };