Synchronize changes from 1.6 master branch [ci skip]

b162464 GPU driver handling tweaks that will improve stability for users affected by a range of graphics device-related issues

Author: github-actions[bot]

Client/core/DXHook/CDirect3DEvents9.cpp

@@ -76,6 +76,21 @@ void CDirect3DEvents9::OnInvalidate(IDirect3DDevice9* pDevice)
 {
     WriteDebugEvent("CDirect3DEvents9::OnInvalidate");
 
+    // Ensure device is in a valid state before invalidation
+    // For example, Nvidia drivers can hang if device operations are attempted during invalid states
+    if (pDevice->TestCooperativeLevel() == D3DERR_DEVICELOST)
+    {
+        WriteDebugEvent("OnInvalidate: Device already lost, skipping operations");
+        return;
+    }
+
+    // Flush any pending operations before invalidation
+    g_pCore->GetGraphics()->GetRenderItemManager()->SaveReadableDepthBuffer();
+    g_pCore->GetGraphics()->GetRenderItemManager()->FlushNonAARenderTarget();
+    
+    // Force completion of all GPU operations
+    pDevice->EndScene(); // Ensure we're not in scene during invalidation
+    
     // Invalidate the VMR9 Manager
     // CVideoManager::GetSingleton ().OnLostDevice ();
 

Client/core/DXHook/CProxyDirect3DDevice9.cpp

@@ -187,7 +187,24 @@ ULONG CProxyDirect3DDevice9::Release()
 /*** IDirect3DDevice9 methods ***/
 HRESULT CProxyDirect3DDevice9::TestCooperativeLevel()
 {
-    return m_pDevice->TestCooperativeLevel();
+    HRESULT hResult = m_pDevice->TestCooperativeLevel();
+    
+    // Log device state transitions for debugging GPU driver issues
+    static HRESULT lastResult = D3D_OK;
+    if (hResult != lastResult)
+    {
+        WriteDebugEvent(SString("CProxyDirect3DDevice9::TestCooperativeLevel - Device state changed: %08x -> %08x", lastResult, hResult));
+        lastResult = hResult;
+        
+        // Additional safety for when transitioning to/from lost states
+        if (hResult == D3DERR_DEVICELOST || hResult == D3DERR_DEVICENOTRESET)
+        {
+            // Give the driver a moment to stabilize
+            Sleep(1);
+        }
+    }
+    
+    return hResult;
 }
 
 UINT CProxyDirect3DDevice9::GetAvailableTextureMem()
@@ -356,6 +373,19 @@ HRESULT CProxyDirect3DDevice9::Reset(D3DPRESENT_PARAMETERS* pPresentationParamet
         WriteDebugEvent("CProxyDirect3DDevice9::Reset - Invalid presentation parameters");
         return D3DERR_INVALIDCALL;
     }
+    
+    // Check cooperative level before attempting reset
+    HRESULT hCoopLevel = m_pDevice->TestCooperativeLevel();
+    if (hCoopLevel == D3DERR_DEVICELOST)
+    {
+        WriteDebugEvent("Reset: Device still lost, cannot reset yet");
+        return hCoopLevel;
+    }
+    else if (hCoopLevel != D3DERR_DEVICENOTRESET && hCoopLevel != D3D_OK)
+    {
+        WriteDebugEvent(SString("CProxyDirect3DDevice9::Reset - Device in unexpected state: %08x", hCoopLevel));
+        return hCoopLevel;
+    }
 
     // Save presentation parameters
     D3DPRESENT_PARAMETERS presentationParametersOrig = *pPresentationParameters;
@@ -367,6 +397,9 @@ HRESULT CProxyDirect3DDevice9::Reset(D3DPRESENT_PARAMETERS* pPresentationParamet
     // Call our event handler.
     CDirect3DEvents9::OnInvalidate(m_pDevice);
 
+    // Give GPU driver time to complete any pending operations
+    Sleep(1);
+    
     // Call the real reset routine.
     hResult = DoResetDevice(m_pDevice, pPresentationParameters, presentationParametersOrig);
 
@@ -408,8 +441,13 @@ HRESULT CProxyDirect3DDevice9::Reset(D3DPRESENT_PARAMETERS* pPresentationParamet
     // Update our data.
     m_pData->StoreViewport(0, 0, pPresentationParameters->BackBufferWidth, pPresentationParameters->BackBufferHeight);
 
-    // Call our event handler.
-    CDirect3DEvents9::OnRestore(m_pDevice);
+        // Ensure scene state is properly restored
+        // Call our event handler.
+        CDirect3DEvents9::OnRestore(m_pDevice);
+        
+        // Additional sync point for GPU driver
+        m_pDevice->BeginScene();
+        m_pDevice->EndScene();
 
     WriteDebugEvent(SString("    BackBufferWidth:%d  Height:%d  Format:%d  Count:%d", pPresentationParameters->BackBufferWidth,
                             pPresentationParameters->BackBufferHeight, pPresentationParameters->BackBufferFormat, pPresentationParameters->BackBufferCount));

Client/core/Graphics/CGraphics.cpp

@@ -1515,10 +1515,11 @@ void CGraphics::DrawTexture(CTextureItem* pTexture, float fX, float fY, float fS
     D3DXVECTOR2 scaling(fScaleX * fFileWidth / fCutWidth, fScaleY * fFileHeight / fCutHeight);
     D3DXVECTOR2 rotationCenter(fFileWidth * fScaleX * fCenterX, fFileHeight * fScaleX * fCenterY);
     D3DXVECTOR2 position(fX - fFileWidth * fScaleX * fCenterX, fY - fFileHeight * fScaleY * fCenterY);
-    D3DXMatrixTransformation2D(&matrix, NULL, NULL, &scaling, &rotationCenter, DegreesToRadians(fRotation), &position);
+    const D3DXVECTOR2* pRotationCenter = fRotation != 0.0f ? &rotationCenter : NULL;
+    D3DXMatrixTransformation2D(&matrix, NULL, NULL, &scaling, pRotationCenter, DegreesToRadians(fRotation), &position);
     CheckModes(EDrawMode::DX_SPRITE, m_ActiveBlendMode);
     m_pDXSprite->SetTransform(&matrix);
-    m_pDXSprite->Draw((IDirect3DTexture9*)pTexture->m_pD3DTexture, &cutImagePos, NULL, NULL, /*ModifyColorForBlendMode (*/ dwColor /*, blendMode )*/);
+    m_pDXSprite->Draw((IDirect3DTexture9*)pTexture->m_pD3DTexture, &cutImagePos, NULL, NULL, dwColor);
     EndDrawBatch();
 }
 
@@ -1763,7 +1764,7 @@ void CGraphics::DrawQueueItem(const sDrawQueueItem& Item)
             D3DXVECTOR2  scaling(Item.Text.fScaleX, Item.Text.fScaleY);
             D3DXVECTOR2  translation(fPosFracX * Item.Text.fScaleX, fPosFracY * Item.Text.fScaleY);            // Sub-pixel positioning
             D3DXVECTOR2  rotcenter(Item.Text.fRotationCenterX, Item.Text.fRotationCenterY);
-            D3DXVECTOR2* pRotcenter = Item.Text.fRotation ? &rotcenter : NULL;
+            const D3DXVECTOR2* pRotcenter = Item.Text.fRotation != 0.0f ? &rotcenter : NULL;
             D3DXMatrixTransformation2D(&matrix, NULL, 0.0f, &scaling, pRotcenter, DegreesToRadians(Item.Text.fRotation), &translation);
             CheckModes(EDrawMode::DX_SPRITE, Item.blendMode);
             m_pDXSprite->SetTransform(&matrix);
@@ -1789,7 +1790,7 @@ void CGraphics::DrawQueueItem(const sDrawQueueItem& Item)
                 const float       fCutWidth = cutImagePos.right - cutImagePos.left;
                 const float       fCutHeight = cutImagePos.bottom - cutImagePos.top;
                 const D3DXVECTOR2 scaling(Item.Texture.fWidth / fCutWidth, Item.Texture.fHeight / fCutHeight);
-                const D3DXVECTOR2 rotationCenter(Item.Texture.fWidth * 0.5f + Item.Texture.fRotCenOffX, Item.Texture.fHeight * 0.5f + Item.Texture.fRotCenOffY);
+                const D3DXVECTOR2 rotationCenter(fFileWidth * 0.5f + Item.Texture.fRotCenOffX, fFileHeight * 0.5f + Item.Texture.fRotCenOffY);
                 const D3DXVECTOR2 position(Item.Texture.fX, Item.Texture.fY);
                 const D3DXVECTOR2* pRotationCenter = Item.Texture.fRotation ? &rotationCenter : NULL;
                 D3DXMATRIX         matrix;
@@ -2003,9 +2004,23 @@ void CGraphics::MaybeLeavingMTARenderZone()
 ////////////////////////////////////////////////////////////////
 void CGraphics::SaveGTARenderStates()
 {
+    // Prevent GPU driver hang by checking device state before creating state blocks
+    if (m_pDevice->TestCooperativeLevel() != D3D_OK)
+    {
+        WriteDebugEvent("CGraphics::SaveGTARenderStates - Device not cooperative, skipping state block creation");
+        return;
+    }
+
     SAFE_RELEASE(m_pSavedStateBlock);
-    // Create a state block.
-    m_pDevice->CreateStateBlock(D3DSBT_ALL, &m_pSavedStateBlock);
+    
+    // Add error handling for state block creation
+    HRESULT hr = m_pDevice->CreateStateBlock(D3DSBT_ALL, &m_pSavedStateBlock);
+    if (FAILED(hr))
+    {
+        WriteDebugEvent(SString("CGraphics::SaveGTARenderStates - Failed to create state block: %08x", hr));
+        m_pSavedStateBlock = nullptr;
+        return;
+    }
 
     // Make sure linear sampling is enabled
     m_pDevice->SetSamplerState(0, D3DSAMP_MAGFILTER, D3DTEXF_LINEAR);
@@ -2025,6 +2040,14 @@ void CGraphics::SaveGTARenderStates()
 ////////////////////////////////////////////////////////////////
 void CGraphics::RestoreGTARenderStates()
 {
+    // Check device state before attempting to restore
+    if (m_pDevice->TestCooperativeLevel() != D3D_OK)
+    {
+        WriteDebugEvent("CGraphics::RestoreGTARenderStates - Device not cooperative, skipping state restoration");
+        SAFE_RELEASE(m_pSavedStateBlock);
+        return;
+    }
+
     // Restore these transforms to fix various weird stuff
     m_pDevice->SetTransform(D3DTS_PROJECTION, &g_pDeviceState->TransformState.PROJECTION);
     m_pDevice->SetTransform(D3DTS_WORLD, &g_pDeviceState->TransformState.WORLD);
@@ -2033,7 +2056,12 @@ void CGraphics::RestoreGTARenderStates()
     // Restore the render states
     if (m_pSavedStateBlock)
     {
-        m_pSavedStateBlock->Apply();
+        // Error handling for state block apply
+        HRESULT hr = m_pSavedStateBlock->Apply();
+        if (FAILED(hr))
+        {
+            WriteDebugEvent(SString("RestoreGTARenderStates: Failed to apply state block: %08x", hr));
+        }
         SAFE_RELEASE(m_pSavedStateBlock);
     }
 }

Client/core/Graphics/CRenderItemManager.cpp

@@ -1181,6 +1181,19 @@ void CRenderItemManager::SaveReadableDepthBuffer()
     {
         m_bUsingReadableDepthBuffer = false;
 
+        // Ensure device operations are synchronous for GPU driver (especially Nvidia) compatibility
+        IDirect3DSurface9* pCurrentDepthSurface = nullptr;
+        if (SUCCEEDED(m_pDevice->GetDepthStencilSurface(&pCurrentDepthSurface)))
+        {
+            // Force GPU to complete any pending depth buffer operations
+            D3DLOCKED_RECT lockedRect;
+            if (SUCCEEDED(pCurrentDepthSurface->LockRect(&lockedRect, nullptr, D3DLOCK_READONLY | D3DLOCK_DONOTWAIT)))
+            {
+                pCurrentDepthSurface->UnlockRect();
+            }
+            SAFE_RELEASE(pCurrentDepthSurface);
+        }
+
         if (m_pNonAADepthSurface2)
         {
             // If using AA hacks, change to the other depth buffer we created
@@ -1196,6 +1209,11 @@ void CRenderItemManager::SaveReadableDepthBuffer()
                 SAFE_RELEASE(m_pSavedSceneDepthSurface);
             }
         }
+        
+        // Additional sync point for GPU driver
+        // Force immediate execution of depth buffer state changes
+        m_pDevice->BeginScene();
+        m_pDevice->EndScene();
     }
 }