D3D fix-ups #3 (Performance)

Author: Dutchman101

Client/core/DXHook/CDirect3DData.cpp

@@ -17,17 +17,16 @@ template <>
 CDirect3DData* CSingleton<CDirect3DData>::m_pSingleton = NULL;
 
 CDirect3DData::CDirect3DData()
+    : m_mViewMatrix{}
+    , m_mProjMatrix{}
+    , m_mWorldMatrix{}
+    , m_hDeviceWindow(0)
+    , m_dwViewportX(0)
+    , m_dwViewportY(0)
+    , m_dwViewportWidth(0)
+    , m_dwViewportHeight(0)
 {
-    // Zero out our matricies.
-    memset(&m_mViewMatrix, 0, sizeof(D3DMATRIX));
-    memset(&m_mProjMatrix, 0, sizeof(D3DMATRIX));
-    memset(&m_mWorldMatrix, 0, sizeof(D3DMATRIX));
-
-    m_hDeviceWindow = 0;
-    m_dwViewportX = 0;
-    m_dwViewportY = 0;
-    m_dwViewportWidth = 0;
-    m_dwViewportHeight = 0;
+
 }
 
 CDirect3DData::~CDirect3DData()
@@ -36,49 +35,65 @@ CDirect3DData::~CDirect3DData()
 
 void CDirect3DData::StoreTransform(D3DTRANSFORMSTATETYPE dwMatrixToStore, const D3DMATRIX* pMatrix)
 {
+    if (!pMatrix)
+        return;
+
+    // Use direct assignment instead of memcpy for better performance
     switch (dwMatrixToStore)
     {
         case D3DTS_VIEW:
-            // Copy the real view matrix.
-            memcpy(&m_mViewMatrix, pMatrix, sizeof(D3DMATRIX));
+            m_mViewMatrix = *pMatrix;
             break;
         case D3DTS_PROJECTION:
-            // Copy the real projection marix.
-            memcpy(&m_mProjMatrix, pMatrix, sizeof(D3DMATRIX));
+            m_mProjMatrix = *pMatrix;
             break;
         case D3DTS_WORLD:
-            // Copy the real world matrix.
-            memcpy(&m_mWorldMatrix, pMatrix, sizeof(D3DMATRIX));
+            m_mWorldMatrix = *pMatrix;
             break;
         default:
-            // Do nothing.
+            // Do nothing for unsupported transforms
             break;
     }
 }
 
 void CDirect3DData::GetTransform(D3DTRANSFORMSTATETYPE dwRequestedMatrix, D3DMATRIX* pMatrixOut)
 {
+    if (!pMatrixOut)
+        return;
+
+    // Use direct assignment instead of memcpy for better performance
     switch (dwRequestedMatrix)
     {
         case D3DTS_VIEW:
-            // Copy the stored view matrix.
-            memcpy(pMatrixOut, &m_mViewMatrix, sizeof(D3DMATRIX));
+            *pMatrixOut = m_mViewMatrix;
             break;
         case D3DTS_PROJECTION:
-            // Copy the stored projection matrix.
-            memcpy(pMatrixOut, &m_mProjMatrix, sizeof(D3DMATRIX));
+            *pMatrixOut = m_mProjMatrix;
             break;
         case D3DTS_WORLD:
-            // Copy the stored world matrix.
-            memcpy(pMatrixOut, &m_mWorldMatrix, sizeof(D3DMATRIX));
+            *pMatrixOut = m_mWorldMatrix;
             break;
         default:
-            // Zero out the structure for the user.
-            memset(pMatrixOut, 0, sizeof(D3DMATRIX));
+            // Zero out for unsupported transforms
+            *pMatrixOut = {};
             break;
     }
+}
 
-    // assert ( 0 );   // Too expensive to be used because SetTransform is used too often
+const D3DMATRIX* CDirect3DData::GetTransformPtr(D3DTRANSFORMSTATETYPE dwRequestedMatrix) const
+{
+    // Return direct pointer to cached matrix - avoids copy overhead
+    switch (dwRequestedMatrix)
+    {
+        case D3DTS_VIEW:
+            return &m_mViewMatrix;
+        case D3DTS_PROJECTION:
+            return &m_mProjMatrix;
+        case D3DTS_WORLD:
+            return &m_mWorldMatrix;
+        default:
+            return nullptr;
+    }
 }
 
 void CDirect3DData::StoreViewport(DWORD dwX, DWORD dwY, DWORD dwWidth, DWORD dwHeight)

Client/core/DXHook/CDirect3DData.h

@@ -22,6 +22,7 @@ class CDirect3DData : public CSingleton<CDirect3DData>
 
     void StoreTransform(D3DTRANSFORMSTATETYPE dwMatrixToStore, const D3DMATRIX* pMatrix);
     void GetTransform(D3DTRANSFORMSTATETYPE dwRequestedMatrix, D3DMATRIX* pMatrixOut);
+    const D3DMATRIX* GetTransformPtr(D3DTRANSFORMSTATETYPE dwRequestedMatrix) const;
 
     HWND GetDeviceWindow() { return m_hDeviceWindow; };
     void StoreDeviceWindow(HWND hDeviceWindow) { m_hDeviceWindow = hDeviceWindow; };

Client/core/DXHook/CProxyDirect3D9.cpp

@@ -24,6 +24,9 @@ namespace
 // Cached static Direct3D pointer for lockless fast-path access
 std::atomic<IDirect3D9*> g_cachedStaticDirect3D{nullptr};
 std::atomic<bool>        g_cachedDirect3DValid{false};
+// Cached adapter monitor for lockless fast-path access
+std::atomic<HMONITOR>    g_cachedAdapterMonitor{nullptr};
+std::atomic<bool>        g_cachedAdapterMonitorValid{false};
 
 IDirect3D9* GetFirstValidTrackedDirect3D(std::vector<IDirect3D9*>& trackedList)
 {
@@ -85,8 +88,9 @@ CProxyDirect3D9::~CProxyDirect3D9()
     {
         std::lock_guard<std::mutex> lock(ms_Direct3D9ListMutex);
         ListRemove(ms_CreatedDirect3D9List, m_pDevice);
-        // Invalidate cache when removing this device
+        // Invalidate both caches when removing this device
         g_cachedDirect3DValid.store(false, std::memory_order_release);
+        g_cachedAdapterMonitorValid.store(false, std::memory_order_release);
     }
     ReleaseInterface(m_pDevice, 8752);
 }
@@ -232,12 +236,30 @@ HMONITOR CProxyDirect3D9::GetAdapterMonitor(UINT Adapter)
 
 HMONITOR CProxyDirect3D9::StaticGetAdapterMonitor(UINT Adapter)
 {
+    // Fast path: use cached monitor without lock (for default adapter 0)
+    if (Adapter == 0 && g_cachedAdapterMonitorValid.load(std::memory_order_acquire))
+    {
+        HMONITOR hMonitor = g_cachedAdapterMonitor.load(std::memory_order_acquire);
+        if (hMonitor)
+            return hMonitor;
+    }
+    
+    // Slow path: refresh cache under lock
     std::lock_guard<std::mutex> lock(ms_Direct3D9ListMutex);
     IDirect3D9* pDirect3D = GetFirstValidTrackedDirect3D(ms_CreatedDirect3D9List);
     if (!pDirect3D)
         return NULL;
 
-    return pDirect3D->GetAdapterMonitor(Adapter);
+    HMONITOR hMonitor = pDirect3D->GetAdapterMonitor(Adapter);
+    
+    // Cache result for default adapter
+    if (Adapter == 0 && hMonitor)
+    {
+        g_cachedAdapterMonitor.store(hMonitor, std::memory_order_release);
+        g_cachedAdapterMonitorValid.store(true, std::memory_order_release);
+    }
+    
+    return hMonitor;
 }
 
 IDirect3D9* CProxyDirect3D9::StaticGetDirect3D()

Client/core/DXHook/CProxyDirect3DDevice9.cpp

@@ -836,7 +836,7 @@ HRESULT CProxyDirect3DDevice9::Reset(D3DPRESENT_PARAMETERS* pPresentationParamet
 HRESULT CProxyDirect3DDevice9::Present(CONST RECT* pSourceRect, CONST RECT* pDestRect, HWND hDestWindowOverride, CONST RGNDATA* pDirtyRegion)
 {
     // Reset frame stat counters
-    memset(&DeviceState.FrameStats, 0, sizeof(DeviceState.FrameStats));
+    DeviceState.FrameStats = {};
 
     bool    bDeviceTemporarilyLost = false;
     HRESULT hrCoopLevel = D3DERR_INVALIDCALL;
@@ -848,9 +848,11 @@ HRESULT CProxyDirect3DDevice9::Present(CONST RECT* pSourceRect, CONST RECT* pDes
     CDirect3DEvents9::OnPresent(m_pDevice);
 
     // A fog flicker fix for some ATI cards
-    D3DMATRIX projMatrix;
-    m_pData->GetTransform(D3DTS_PROJECTION, &projMatrix);
-    m_pDevice->SetTransform(D3DTS_PROJECTION, &projMatrix);
+    const D3DMATRIX* pCachedProjection = m_pData->GetTransformPtr(D3DTS_PROJECTION);
+    if (pCachedProjection)
+    {
+        m_pDevice->SetTransform(D3DTS_PROJECTION, pCachedProjection);
+    }
 
     TIMING_GRAPH("Present");
     HRESULT hr = CDirect3DEvents9::PresentGuarded(m_pDevice, pSourceRect, pDestRect, hDestWindowOverride, pDirtyRegion);
@@ -1195,6 +1197,17 @@ HRESULT CProxyDirect3DDevice9::SetTransform(D3DTRANSFORMSTATETYPE State, CONST D
 
 HRESULT CProxyDirect3DDevice9::GetTransform(D3DTRANSFORMSTATETYPE State, D3DMATRIX* pMatrix)
 {
+    // Use cached data if available to avoid expensive device query
+    if (pMatrix)
+    {
+        const D3DMATRIX* pCached = m_pData->GetTransformPtr(State);
+        if (pCached)
+        {
+            *pMatrix = *pCached;
+            return D3D_OK;
+        }
+    }
+    // Fallback to device query for unsupported transform types
     return m_pDevice->GetTransform(State, pMatrix);
 }