How to create a DirectX rendering loop that uses IDXGIOutput::WaitForVBlank

[ackh]

I'm attempting to port an UWP app that is written in C++/WinRT and uses DirectX (SwapChainPanel) over to the Windows App SDK. However, I'm struggling with how to port the rendering thread/loop.

The rendering loop of the UWP app is essentially a copy of one of the UWP sample apps that Microsoft originally provided. The code looks as follows:

// header file
private:
  winrt::Windows::Foundation::IAsyncAction _renderLoopWorker;

// cpp file
MyApp::~MyApp()
{
  _renderLoopWorker.Cancel();
}

void MyApp::StartRenderingLoop()
{
  if(_renderLoopWorker != nullptr && _renderLoopWorker.Status() == AsyncStatus::Started)
  {
    return;
  }

  WorkItemHandler workItemHandler = WorkItemHandler([this](IAsyncAction action)
  {
    while(action.Status() == AsyncStatus::Started)
    {
      Concurrency::critical_section::scoped_lock lock(_criticalSection);

      if(_renderer->Render())
      {
        Present();
      }

      _dxgiOutput->WaitForVBlank();
    }
  });

  _renderLoopWorker = ThreadPool::RunAsync(workItemHandler, WorkItemPriority::High, WorkItemOptions::TimeSliced);
}

The ported rendering loop utilizes a DispatcherQueueController instead of an IAsyncAction because I just could not get the ThreadPool::RunAsync to run. The code looks as follows:

// header file
private:
  winrt::Microsoft::UI::Dispatching::DispatcherQueueController _renderLoopController{ nullptr };
  bool _isRenderLoopRunning = false;

// cpp file
MyApp::~MyApp()
{
  _isRenderLoopRunning = false;
  _renderLoopController.ShutdownQueueAsync();
}

void MyApp::StartRenderingLoop()
{
  if(!_isRenderLoopRunning)
  {
    _renderLoopController = DispatcherQueueController::CreateOnDedicatedThread();
    _isRenderLoopRunning  = _renderLoopController.DispatcherQueue().TryEnqueue([this]()
    {
      while(_isRenderLoopRunning)
      {
        Concurrency::critical_section::scoped_lock lock(_criticalSection);

        if(_renderer->Render())
        {
          Present();
        }

        _dxgiOutput->WaitForVBlank();
      }
    });
  }
}

The ported code compiles and it does run. However, if I add multiple DirectX components to my app and switch between them (they're on different tabs) in debug mode I get the following assertion:

---------------------------
Microsoft Visual C++ Runtime Library
---------------------------
Debug Assertion Failed!

Program: ...bug.UWPDesktop_14.0.30704.0_x64__8wekyb3d8bbwe\CONCRT140D.dll
File: d:\a01\_work\3\s\src\vctools\crt\crtw32\concrt\rtlocks.cpp
Line: 1001

Expression: Lock was destructed while held

For information on how your program can cause an assertion
failure, see the Visual C++ documentation on asserts.

(Press Retry to debug the application)

---------------------------
Abort   Retry   Ignore   
---------------------------

I then realized that if I comment out the line

        _dxgiOutput->WaitForVBlank();

the assertion does not appear. According to the documentation WaitForVBlank "halts a thread until the next vertical blank occurs" which means that the code renders frames in sync with the monitor refresh rate. That is precisely what I want but I just cannot get DispatcherQueueController to collaborate with WaitForVBlank.

What would be the proper way to create a Windows App SDK compatible DirectX rendering loop that makes use of WaitForVBlank?

[DarranRowe]

The big thing to remember is that the sample you reference uses a lambda passed into the stepped timer class to do the present. This means that the lock is in the same scope as the Present call, not the WaitForVBlank call. This means that the lock should be destroyed when the call to WaitForVBlank occurs.