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

It includes:

- Better device state validation
- Added device state checking with TestCooperativeLevel() before creating state blocks
- Added error handling and device state validation before restoring render states
- Early exit on device calls if device already lost (Avoids dangerous operations like calling to invalidate a device that's already so, due to Alt-Tab)
- Ensure completion of GPU operations before invalidation
- Properly flushes depth buffers and render targets before invalidation
- Improve SaveReadableDepthBuffer in CRenderItemManager.cpp
- Added critical sync points for Nvidia compatibility
- Added safe depth buffer locking with D3DLOCK_READONLY | D3DLOCK_DONOTWAIT
- OnInvalidate fixes in CDirect3DEvents9.cpp

I want to specifically target the notorious Nvidia Alt+Tab freeze (Desktop lock-up) issue that affects players with Nvidia graphics cards.
1.	Alt+Tabbing during gameplay would cause the DirectX device to lose and restore state
2.	Nvidia drivers would hang during state block operations if the device was in an invalid state

GPU synchronization issues during depth buffer operations can cause indefinite hangs or suspended waits.

We now have:
- Safe device state validation before any critical DirectX operations
- Proper GPU synchronization during device transitions
- Graceful handling of device loss states
- Relevant debug logging

Author: Dutchman101

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();
     }
 }