diff --git a/renderdoc/core/core.cpp b/renderdoc/core/core.cpp
index 17db50ecd..3e638b99d 100644
--- a/renderdoc/core/core.cpp
+++ b/renderdoc/core/core.cpp
@@ -754,51 +754,46 @@ void RenderDoc::RegisterShutdownFunction(ShutdownFunction func)
     m_ShutdownFunctions.insert(it - m_ShutdownFunctions.begin(), func);
 }
 
-bool RenderDoc::MatchClosestWindow(void *&dev, void *&wnd)
+bool RenderDoc::MatchClosestWindow(DeviceOwnedWindow &devWnd)
 {
-  DeviceWnd dw(dev, wnd);
-
   // lower_bound and the DeviceWnd ordering (pointer compares, dev over wnd) means that if either
-  // element in dw is NULL we can go forward from this iterator and find the first wildcardMatch
+  // element in devWnd is NULL we can go forward from this iterator and find the first wildcardMatch
   // note that if dev is specified and wnd is NULL, this will actually point at the first
   // wildcardMatch already and we can use it immediately (since which window of multiple we
   // choose is undefined, so up to us). If dev is NULL there is no window ordering (since dev is
   // the primary sorting value) so we just iterate through the whole map. It should be small in
   // the majority of cases
-  auto it = m_WindowFrameCapturers.lower_bound(dw);
+  auto it = m_WindowFrameCapturers.lower_bound(devWnd);
 
   while(it != m_WindowFrameCapturers.end())
   {
-    if(it->first.wildcardMatch(dw))
+    if(it->first.wildcardMatch(devWnd))
       break;
     ++it;
   }
 
   if(it != m_WindowFrameCapturers.end())
   {
-    dev = it->first.dev;
-    wnd = it->first.wnd;
+    devWnd = it->first;
     return true;
   }
 
   return false;
 }
 
-IFrameCapturer *RenderDoc::MatchFrameCapturer(void *dev, void *wnd)
+IFrameCapturer *RenderDoc::MatchFrameCapturer(DeviceOwnedWindow devWnd)
 {
-  DeviceWnd dw(dev, wnd);
-
   // try and find the closest frame capture registered, and update
-  // the values in dw to point to it precisely
-  bool exactMatch = MatchClosestWindow(dw.dev, dw.wnd);
+  // the values in devWnd to point to it precisely
+  bool exactMatch = MatchClosestWindow(devWnd);
 
   if(!exactMatch)
   {
     // handle off-screen rendering where there are no device/window pairs in
     // m_WindowFrameCapturers, instead we use the first matching device frame capturer
-    if(wnd == NULL)
+    if(devWnd.windowHandle == NULL)
     {
-      auto defaultit = m_DeviceFrameCapturers.find(dev);
+      auto defaultit = m_DeviceFrameCapturers.find(devWnd.device);
       if(defaultit == m_DeviceFrameCapturers.end() && !m_DeviceFrameCapturers.empty())
         defaultit = m_DeviceFrameCapturers.begin();
 
@@ -809,11 +804,12 @@ IFrameCapturer *RenderDoc::MatchFrameCapturer(void *dev, void *wnd)
     RDCERR(
         "Couldn't find matching frame capturer for device %p window %p "
         "from %zu device frame capturers and %zu frame capturers",
-        dev, wnd, m_DeviceFrameCapturers.size(), m_WindowFrameCapturers.size());
+        devWnd.device, devWnd.windowHandle, m_DeviceFrameCapturers.size(),
+        m_WindowFrameCapturers.size());
     return NULL;
   }
 
-  auto it = m_WindowFrameCapturers.find(dw);
+  auto it = m_WindowFrameCapturers.find(devWnd);
 
   if(it == m_WindowFrameCapturers.end())
   {
@@ -824,48 +820,47 @@ IFrameCapturer *RenderDoc::MatchFrameCapturer(void *dev, void *wnd)
   return it->second.FrameCapturer;
 }
 
-void RenderDoc::StartFrameCapture(void *dev, void *wnd)
+void RenderDoc::StartFrameCapture(DeviceOwnedWindow devWnd)
 {
-  IFrameCapturer *frameCap = MatchFrameCapturer(dev, wnd);
+  IFrameCapturer *frameCap = MatchFrameCapturer(devWnd);
   if(frameCap)
   {
-    frameCap->StartFrameCapture(dev, wnd);
+    frameCap->StartFrameCapture(devWnd);
     m_CapturesActive++;
   }
 }
 
-void RenderDoc::SetActiveWindow(void *dev, void *wnd)
+void RenderDoc::SetActiveWindow(DeviceOwnedWindow devWnd)
 {
-  DeviceWnd dw(dev, wnd);
-
-  auto it = m_WindowFrameCapturers.find(dw);
+  auto it = m_WindowFrameCapturers.find(devWnd);
   if(it == m_WindowFrameCapturers.end())
   {
-    RDCERR("Couldn't find frame capturer for device %p window %p", dev, wnd);
+    RDCERR("Couldn't find frame capturer for device %p window %p", devWnd.device,
+           devWnd.windowHandle);
     return;
   }
 
-  m_ActiveWindow = dw;
+  m_ActiveWindow = devWnd;
 }
 
-bool RenderDoc::EndFrameCapture(void *dev, void *wnd)
+bool RenderDoc::EndFrameCapture(DeviceOwnedWindow devWnd)
 {
-  IFrameCapturer *frameCap = MatchFrameCapturer(dev, wnd);
+  IFrameCapturer *frameCap = MatchFrameCapturer(devWnd);
   if(frameCap)
   {
-    bool ret = frameCap->EndFrameCapture(dev, wnd);
+    bool ret = frameCap->EndFrameCapture(devWnd);
     m_CapturesActive--;
     return ret;
   }
   return false;
 }
 
-bool RenderDoc::DiscardFrameCapture(void *dev, void *wnd)
+bool RenderDoc::DiscardFrameCapture(DeviceOwnedWindow devWnd)
 {
-  IFrameCapturer *frameCap = MatchFrameCapturer(dev, wnd);
+  IFrameCapturer *frameCap = MatchFrameCapturer(devWnd);
   if(frameCap)
   {
-    bool ret = frameCap->DiscardFrameCapture(dev, wnd);
+    bool ret = frameCap->DiscardFrameCapture(devWnd);
     m_CapturesActive--;
     return ret;
   }
@@ -965,21 +960,127 @@ void RenderDoc::CycleActiveWindow()
   }
 }
 
-rdcstr RenderDoc::GetOverlayText(RDCDriver driver, uint32_t frameNumber, int flags)
+rdcstr RenderDoc::GetOverlayText(RDCDriver driver, DeviceOwnedWindow devWnd, uint32_t frameNumber,
+                                 int flags)
 {
-  const bool activeWindow = (flags & eOverlay_ActiveWindow);
+  const bool activeWindow = (devWnd == m_ActiveWindow);
   const bool capturesEnabled = (flags & eOverlay_CaptureDisabled) == 0;
 
   uint32_t overlay = GetOverlayBits();
 
-  rdcstr overlayText = ToStr(driver) + ". ";
+  RDCDriver activeDriver = RDCDriver::Unknown;
+  RDCDriver curDriver = RDCDriver::Unknown;
+
+  int activeIdx = -1, curIdx = -1, idx = 0;
+  for(auto it = m_WindowFrameCapturers.begin(); it != m_WindowFrameCapturers.end(); ++it, ++idx)
+  {
+    if(it->first == m_ActiveWindow)
+    {
+      activeIdx = idx;
+      activeDriver = it->second.FrameCapturer->GetFrameCaptureDriver();
+    }
+    if(it->first == devWnd)
+    {
+      curIdx = idx;
+      curDriver = it->second.FrameCapturer->GetFrameCaptureDriver();
+    }
+  }
+
+  if(activeDriver == RDCDriver::Unknown)
+    activeDriver = curDriver;
+
+  if(activeDriver == RDCDriver::Unknown)
+    activeDriver = driver;
+
+  // example layout:
+  //
+  // Capturing D3D11.  Frame: 1234. 33ms (30 FPS)
+  // F12, PrtScrn to capture. 3 Captures saved.
+  // Captured frame 1200.
+  //
+  // Frame number, FPS, capture list are optional. If capture list is disabled
+  // the second line still displays the keys as long as capturing is allowed.
+  // if capturing is disabled, only the first line displays.
+  //
+  // On platforms without keyboards, the keys are replaced by a remote access connection status
+  // message.
+  //
+  // with multiple windows the active window will look like:
+  //
+  // Capturing D3D11.  Window 1 active. Frame: 1234. 33ms (30 FPS)
+  // F12, PrtScrn to capture. 3 Captures saved.
+  // Captured frame 1200.
+  //
+  // Inactive windows will look like:
+  //
+  // Capturing D3D11.  Window 1 active.
+  // F11 to cycle. OpenGL window 2.
+
+  rdcstr overlayText = ToStr(activeDriver) + ".";
+
+  // pad this so it's the same length regardless of API length
+  while(overlayText.length() < 8)
+    overlayText.push_back(' ');
+
+  overlayText = "Capturing " + overlayText;
+
+  size_t numWindows = m_WindowFrameCapturers.size();
+
+  if(numWindows > 1)
+  {
+    if(activeIdx >= 0)
+      overlayText += StringFormat::Fmt(" Window %d active.", activeIdx);
+    else
+      overlayText += " No window active.";
+  }
 
   if(activeWindow)
   {
-    rdcarray<RENDERDOC_InputButton> keys = GetCaptureKeys();
+    if(overlay & eRENDERDOC_Overlay_FrameNumber)
+      overlayText += StringFormat::Fmt(" Frame: %d.", frameNumber);
 
-    if(capturesEnabled)
+    if(overlay & eRENDERDOC_Overlay_FrameRate)
     {
+      const double frameTime = m_FrameTimer.GetAvgFrameTime();
+      // max with 0.01ms so that we don't divide by zero
+      const double fps = 1000.0f / RDCMAX(0.01, frameTime);
+
+      if(frameTime < 0.0001)
+      {
+        overlayText += " --- ms (--- FPS)";
+      }
+      else
+      {
+        // only display frametime fractions if it's relevant (sub-integer frame time or FPS)
+
+        if(frameTime < 1.0)
+          overlayText += StringFormat::Fmt(" %.2lf ms", m_FrameTimer.GetAvgFrameTime());
+        else
+          overlayText += StringFormat::Fmt(" %d ms", int(m_FrameTimer.GetAvgFrameTime()));
+
+        if(fps < 1.0)
+          overlayText += StringFormat::Fmt(" (%.2lf FPS)", fps);
+        else
+          overlayText += StringFormat::Fmt(" (%d FPS)", int(fps));
+      }
+    }
+  }
+
+  overlayText += "\n";
+
+#if ENABLED(RDOC_DEVEL)
+  {
+    overlayText += StringFormat::Fmt("%llu chunks - %.2f MB\n", Chunk::NumLiveChunks(),
+                                     float(Chunk::TotalMem()) / 1024.0f / 1024.0f);
+  }
+#endif
+
+  if(capturesEnabled)
+  {
+    if(activeWindow)
+    {
+      rdcarray<RENDERDOC_InputButton> keys = GetCaptureKeys();
+
       if(Keyboard::PlatformHasKeyInput())
       {
         for(size_t i = 0; i < keys.size(); i++)
@@ -1000,80 +1101,56 @@ rdcstr RenderDoc::GetOverlayText(RDCDriver driver, uint32_t frameNumber, int fla
         else
           overlayText += "No remote access connection.";
       }
-    }
 
-    if(overlay & eRENDERDOC_Overlay_FrameNumber)
-    {
-      overlayText += StringFormat::Fmt(" Frame: %d.", frameNumber);
-    }
-    if(overlay & eRENDERDOC_Overlay_FrameRate)
-    {
-      overlayText +=
-          StringFormat::Fmt(" %.2lf ms (%.2lf .. %.2lf) (%.0lf FPS)", m_FrameTimer.GetAvgFrameTime(),
-                            m_FrameTimer.GetMinFrameTime(), m_FrameTimer.GetMaxFrameTime(),
-                            // max with 0.01ms so that we don't divide by zero
-                            1000.0f / RDCMAX(0.01, m_FrameTimer.GetAvgFrameTime()));
-    }
-
-    overlayText += "\n";
-
-    if((overlay & eRENDERDOC_Overlay_CaptureList) && capturesEnabled)
-    {
-      overlayText += StringFormat::Fmt("%d Captures saved.\n", (uint32_t)m_Captures.size());
-
-      uint64_t now = Timing::GetUnixTimestamp();
-      for(size_t i = 0; i < m_Captures.size(); i++)
+      if(overlay & eRENDERDOC_Overlay_CaptureList)
       {
-        if(now - m_Captures[i].timestamp < 20)
+        overlayText += StringFormat::Fmt(" %d Captures saved.\n", (uint32_t)m_Captures.size());
+
+        uint64_t now = Timing::GetUnixTimestamp();
+        for(size_t i = 0; i < m_Captures.size(); i++)
         {
-          if(m_Captures[i].frameNumber == ~0U)
-            overlayText += "Captured user-defined capture.\n";
-          else
-            overlayText += StringFormat::Fmt("Captured frame %d.\n", m_Captures[i].frameNumber);
+          if(now - m_Captures[i].timestamp < 20)
+          {
+            if(m_Captures[i].frameNumber == ~0U)
+              overlayText += "Captured user-defined capture.\n";
+            else
+              overlayText += StringFormat::Fmt("Captured frame %d.\n", m_Captures[i].frameNumber);
+          }
         }
       }
     }
-
-#if ENABLED(RDOC_DEVEL)
-    overlayText += StringFormat::Fmt("%llu chunks - %.2f MB\n", Chunk::NumLiveChunks(),
-                                     float(Chunk::TotalMem()) / 1024.0f / 1024.0f);
-#endif
-  }
-  else if(capturesEnabled)
-  {
-    rdcarray<RENDERDOC_InputButton> keys = GetFocusKeys();
-
-    overlayText += "Inactive window.";
-
-    size_t activeIdx = 0;
-    for(auto it = m_WindowFrameCapturers.begin(); it != m_WindowFrameCapturers.end();
-        ++it, ++activeIdx)
-      if(it->first == m_ActiveWindow)
-        break;
-
-    if(activeIdx < m_WindowFrameCapturers.size())
+    else
     {
-      overlayText += StringFormat::Fmt(" Active Window: %zu of %zu.", activeIdx + 1,
-                                       m_WindowFrameCapturers.size());
-    }
+      rdcarray<RENDERDOC_InputButton> keys = GetFocusKeys();
 
-    if(Keyboard::PlatformHasKeyInput())
-    {
-      for(size_t i = 0; i < keys.size(); i++)
+      if(Keyboard::PlatformHasKeyInput())
       {
-        if(i == 0)
-          overlayText += " ";
-        else
-          overlayText += ", ";
+        for(size_t i = 0; i < keys.size(); i++)
+        {
+          if(i > 0)
+            overlayText += ", ";
 
-        overlayText += ToStr(keys[i]);
+          overlayText += ToStr(keys[i]);
+        }
+
+        if(!keys.empty())
+          overlayText += " to cycle.";
+      }
+      else
+      {
+        if(IsTargetControlConnected())
+          overlayText += "Connected by " + GetTargetControlUsername() + ".";
+        else
+          overlayText += "No remote access connection.";
       }
 
-      if(!keys.empty())
-        overlayText += " to cycle between windows";
+      if(curIdx >= 0)
+        overlayText += StringFormat::Fmt(" %s window %d.", ToStr(curDriver).c_str(), curIdx);
+      else if(curDriver != RDCDriver::Unknown)
+        overlayText += StringFormat::Fmt(" Unknown %s window.", ToStr(curDriver).c_str());
+      else
+        overlayText += " Unknown window.";
     }
-
-    overlayText += "\n";
   }
 
   return overlayText;
@@ -1884,23 +1961,22 @@ void RenderDoc::RemoveDeviceFrameCapturer(void *dev)
   m_DeviceFrameCapturers.erase(dev);
 }
 
-void RenderDoc::AddFrameCapturer(void *dev, void *wnd, IFrameCapturer *cap)
+void RenderDoc::AddFrameCapturer(DeviceOwnedWindow devWnd, IFrameCapturer *cap)
 {
   if(IsReplayApp())
     return;
 
-  if(dev == NULL || wnd == NULL || cap == NULL)
+  if(devWnd.device == NULL || devWnd.windowHandle == NULL || cap == NULL)
   {
-    RDCERR("Invalid FrameCapturer %#p for combination: %#p / %#p", cap, dev, wnd);
+    RDCERR("Invalid FrameCapturer %#p for combination: %#p / %#p", cap, devWnd.device,
+           devWnd.windowHandle);
     return;
   }
 
-  RDCLOG("Adding %s frame capturer for %#p / %#p", ToStr(cap->GetFrameCaptureDriver()).c_str(), dev,
-         wnd);
+  RDCLOG("Adding %s frame capturer for %#p / %#p", ToStr(cap->GetFrameCaptureDriver()).c_str(),
+         devWnd.device, devWnd.windowHandle);
 
-  DeviceWnd dw(dev, wnd);
-
-  auto it = m_WindowFrameCapturers.find(dw);
+  auto it = m_WindowFrameCapturers.find(devWnd);
   if(it != m_WindowFrameCapturers.end())
   {
     if(it->second.FrameCapturer != cap)
@@ -1910,24 +1986,22 @@ void RenderDoc::AddFrameCapturer(void *dev, void *wnd, IFrameCapturer *cap)
   }
   else
   {
-    m_WindowFrameCapturers[dw].FrameCapturer = cap;
+    m_WindowFrameCapturers[devWnd].FrameCapturer = cap;
   }
 
   // the first one we see becomes the default
-  if(m_ActiveWindow == DeviceWnd())
-    m_ActiveWindow = dw;
+  if(m_ActiveWindow == DeviceOwnedWindow())
+    m_ActiveWindow = devWnd;
 }
 
-void RenderDoc::RemoveFrameCapturer(void *dev, void *wnd)
+void RenderDoc::RemoveFrameCapturer(DeviceOwnedWindow devWnd)
 {
   if(IsReplayApp())
     return;
 
-  DeviceWnd dw(dev, wnd);
+  RDCLOG("Removing frame capturer for %#p / %#p", devWnd.device, devWnd.windowHandle);
 
-  RDCLOG("Removing frame capturer for %#p / %#p", dev, wnd);
-
-  auto it = m_WindowFrameCapturers.find(dw);
+  auto it = m_WindowFrameCapturers.find(devWnd);
   if(it != m_WindowFrameCapturers.end())
   {
     it->second.RefCount--;
@@ -1936,13 +2010,13 @@ void RenderDoc::RemoveFrameCapturer(void *dev, void *wnd)
     {
       RDCLOG("Removed last refcount");
 
-      if(m_ActiveWindow == dw)
+      if(m_ActiveWindow == devWnd)
       {
         RDCLOG("Removed active window");
 
         if(m_WindowFrameCapturers.size() == 1)
         {
-          m_ActiveWindow = DeviceWnd();
+          m_ActiveWindow = DeviceOwnedWindow();
         }
         else
         {
diff --git a/renderdoc/core/core.h b/renderdoc/core/core.h
index 8fa8f5a81..d728933cb 100644
--- a/renderdoc/core/core.h
+++ b/renderdoc/core/core.h
@@ -67,12 +67,42 @@ struct ICrashHandler
   virtual void UnregisterMemoryRegion(void *mem) = 0;
 };
 
+struct DeviceOwnedWindow
+{
+  DeviceOwnedWindow() : device(NULL), windowHandle(NULL) {}
+  DeviceOwnedWindow(void *dev, void *wnd) : device(dev), windowHandle(wnd) {}
+  void *device;
+  void *windowHandle;
+
+  bool operator==(const DeviceOwnedWindow &o) const
+  {
+    return device == o.device && windowHandle == o.windowHandle;
+  }
+  bool operator<(const DeviceOwnedWindow &o) const
+  {
+    if(device != o.device)
+      return device < o.device;
+    return windowHandle < o.windowHandle;
+  }
+
+  bool wildcardMatch(const DeviceOwnedWindow &o) const
+  {
+    if(device == NULL || o.device == NULL)
+      return windowHandle == NULL || o.windowHandle == NULL || windowHandle == o.windowHandle;
+
+    if(windowHandle == NULL || o.windowHandle == NULL)
+      return device == o.device;
+
+    return *this == o;
+  }
+};
+
 struct IFrameCapturer
 {
   virtual RDCDriver GetFrameCaptureDriver() = 0;
-  virtual void StartFrameCapture(void *dev, void *wnd) = 0;
-  virtual bool EndFrameCapture(void *dev, void *wnd) = 0;
-  virtual bool DiscardFrameCapture(void *dev, void *wnd) = 0;
+  virtual void StartFrameCapture(DeviceOwnedWindow devWnd) = 0;
+  virtual bool EndFrameCapture(DeviceOwnedWindow devWnd) = 0;
+  virtual bool DiscardFrameCapture(DeviceOwnedWindow devWnd) = 0;
 };
 
 struct IDeviceProtocolHandler;
@@ -526,8 +556,8 @@ public:
 
   void Tick();
 
-  void AddFrameCapturer(void *dev, void *wnd, IFrameCapturer *cap);
-  void RemoveFrameCapturer(void *dev, void *wnd);
+  void AddFrameCapturer(DeviceOwnedWindow devWnd, IFrameCapturer *cap);
+  void RemoveFrameCapturer(DeviceOwnedWindow devWnd);
   bool HasActiveFrameCapturer(RDCDriver driver) const;
 
   // add window-less frame capturers for use via users capturing
@@ -535,25 +565,16 @@ public:
   void AddDeviceFrameCapturer(void *dev, IFrameCapturer *cap);
   void RemoveDeviceFrameCapturer(void *dev);
 
-  void StartFrameCapture(void *dev, void *wnd);
+  void StartFrameCapture(DeviceOwnedWindow devWnd);
   bool IsFrameCapturing() { return m_CapturesActive > 0; }
-  void SetActiveWindow(void *dev, void *wnd);
-  bool EndFrameCapture(void *dev, void *wnd);
-  bool DiscardFrameCapture(void *dev, void *wnd);
+  void SetActiveWindow(DeviceOwnedWindow devWnd);
+  bool EndFrameCapture(DeviceOwnedWindow devWnd);
+  bool DiscardFrameCapture(DeviceOwnedWindow devWnd);
 
-  bool MatchClosestWindow(void *&dev, void *&wnd);
-
-  bool IsActiveWindow(void *dev, void *wnd)
-  {
-    return dev == m_ActiveWindow.dev && wnd == m_ActiveWindow.wnd;
-  }
-
-  void GetActiveWindow(void *&dev, void *&wnd)
-  {
-    dev = m_ActiveWindow.dev;
-    wnd = m_ActiveWindow.wnd;
-  }
+  bool MatchClosestWindow(DeviceOwnedWindow &devWnd);
 
+  bool IsActiveWindow(DeviceOwnedWindow devWnd) { return devWnd == m_ActiveWindow; }
+  void GetActiveWindow(DeviceOwnedWindow &devWnd) { devWnd = m_ActiveWindow; }
   void TriggerCapture(uint32_t numFrames) { m_Cap = numFrames; }
   uint32_t GetOverlayBits() { return m_Overlay; }
   void MaskOverlayBits(uint32_t And, uint32_t Or) { m_Overlay = (m_Overlay & And) | Or; }
@@ -577,11 +598,10 @@ public:
 
   enum
   {
-    eOverlay_ActiveWindow = 0x1,
-    eOverlay_CaptureDisabled = 0x2,
+    eOverlay_CaptureDisabled = 0x1,
   };
 
-  rdcstr GetOverlayText(RDCDriver driver, uint32_t frameNumber, int flags);
+  rdcstr GetOverlayText(RDCDriver driver, DeviceOwnedWindow devWnd, uint32_t frameNumber, int flags);
 
   void CycleActiveWindow();
   uint32_t GetCapturableWindowCount() { return (uint32_t)m_WindowFrameCapturers.size(); }
@@ -659,44 +679,17 @@ private:
     int RefCount;
   };
 
-  struct DeviceWnd
-  {
-    DeviceWnd() : dev(NULL), wnd(NULL) {}
-    DeviceWnd(void *d, void *w) : dev(d), wnd(w) {}
-    void *dev;
-    void *wnd;
-
-    bool operator==(const DeviceWnd &o) const { return dev == o.dev && wnd == o.wnd; }
-    bool operator<(const DeviceWnd &o) const
-    {
-      if(dev != o.dev)
-        return dev < o.dev;
-      return wnd < o.wnd;
-    }
-
-    bool wildcardMatch(const DeviceWnd &o) const
-    {
-      if(dev == NULL || o.dev == NULL)
-        return wnd == NULL || o.wnd == NULL || wnd == o.wnd;
-
-      if(wnd == NULL || o.wnd == NULL)
-        return dev == o.dev;
-
-      return *this == o;
-    }
-  };
-
   FloatVector m_LightChecker = FloatVector(0.81f, 0.81f, 0.81f, 1.0f);
   FloatVector m_DarkChecker = FloatVector(0.57f, 0.57f, 0.57f, 1.0f);
   bool m_DarkTheme = false;
 
   int m_CapturesActive;
 
-  std::map<DeviceWnd, FrameCap> m_WindowFrameCapturers;
-  DeviceWnd m_ActiveWindow;
+  std::map<DeviceOwnedWindow, FrameCap> m_WindowFrameCapturers;
+  DeviceOwnedWindow m_ActiveWindow;
   std::map<void *, IFrameCapturer *> m_DeviceFrameCapturers;
 
-  IFrameCapturer *MatchFrameCapturer(void *dev, void *wnd);
+  IFrameCapturer *MatchFrameCapturer(DeviceOwnedWindow devWnd);
 
   bool m_VendorExts[arraydim<VendorExtensions>()] = {};
 
diff --git a/renderdoc/driver/d3d11/d3d11_device.cpp b/renderdoc/driver/d3d11/d3d11_device.cpp
index bee578b5f..856d31451 100644
--- a/renderdoc/driver/d3d11/d3d11_device.cpp
+++ b/renderdoc/driver/d3d11/d3d11_device.cpp
@@ -1918,7 +1918,7 @@ int WrappedID3D11Device::EndEvent()
   return m_pCurrentWrappedDevice->m_pImmediateContext->ThreadSafe_EndEvent();
 }
 
-void WrappedID3D11Device::StartFrameCapture(void *dev, void *wnd)
+void WrappedID3D11Device::StartFrameCapture(DeviceOwnedWindow devWnd)
 {
   SCOPED_LOCK(m_D3DLock);
 
@@ -1975,7 +1975,7 @@ void WrappedID3D11Device::StartFrameCapture(void *dev, void *wnd)
     m_pInfoQueue->ClearStoredMessages();
 }
 
-bool WrappedID3D11Device::EndFrameCapture(void *dev, void *wnd)
+bool WrappedID3D11Device::EndFrameCapture(DeviceOwnedWindow devWnd)
 {
   SCOPED_LOCK(m_D3DLock);
 
@@ -1986,11 +1986,11 @@ bool WrappedID3D11Device::EndFrameCapture(void *dev, void *wnd)
 
   IDXGISwapper *swapper = NULL;
 
-  if(wnd)
+  if(devWnd.windowHandle)
   {
     for(auto it = m_SwapChains.begin(); it != m_SwapChains.end(); ++it)
     {
-      if(it->first->GetHWND() == wnd)
+      if(it->first->GetHWND() == devWnd.windowHandle)
       {
         swapper = it->first;
         break;
@@ -1999,7 +1999,8 @@ bool WrappedID3D11Device::EndFrameCapture(void *dev, void *wnd)
 
     if(swapper == NULL)
     {
-      RDCERR("Output window %p provided for frame capture corresponds with no known swap chain", wnd);
+      RDCERR("Output window %p provided for frame capture corresponds with no known swap chain",
+             devWnd.windowHandle);
       return false;
     }
   }
@@ -2404,7 +2405,7 @@ bool WrappedID3D11Device::EndFrameCapture(void *dev, void *wnd)
   }
 }
 
-bool WrappedID3D11Device::DiscardFrameCapture(void *dev, void *wnd)
+bool WrappedID3D11Device::DiscardFrameCapture(DeviceOwnedWindow devWnd)
 {
   SCOPED_LOCK(m_D3DLock);
 
@@ -2563,7 +2564,7 @@ void WrappedID3D11Device::FirstFrame(IDXGISwapper *swapper)
   // if we have to capture the first frame, begin capturing immediately
   if(IsBackgroundCapturing(m_State) && RenderDoc::Inst().ShouldTriggerCapture(0))
   {
-    RenderDoc::Inst().StartFrameCapture((ID3D11Device *)this, swapper->GetHWND());
+    RenderDoc::Inst().StartFrameCapture(DeviceOwnedWindow((ID3D11Device *)this, swapper->GetHWND()));
 
     m_AppControlledCapture = false;
     m_CapturedFrames.back().frameNumber = 0;
@@ -2617,7 +2618,9 @@ HRESULT WrappedID3D11Device::Present(IDXGISwapper *swapper, UINT SyncInterval, U
 
   m_pImmediateContext->BeginFrame();
 
-  bool activeWindow = RenderDoc::Inst().IsActiveWindow((ID3D11Device *)this, swapper->GetHWND());
+  DeviceOwnedWindow devWnd((ID3D11Device *)this, swapper->GetHWND());
+
+  bool activeWindow = RenderDoc::Inst().IsActiveWindow(devWnd);
 
   m_LastSwap = swapper;
 
@@ -2636,8 +2639,8 @@ HRESULT WrappedID3D11Device::Present(IDXGISwapper *swapper, UINT SyncInterval, U
       m_TextRenderer->SetOutputDimensions(swapper->GetWidth(), swapper->GetHeight());
       m_TextRenderer->SetOutputWindow(swapper->GetHWND());
 
-      int flags = activeWindow ? RenderDoc::eOverlay_ActiveWindow : 0;
-      rdcstr overlayText = RenderDoc::Inst().GetOverlayText(RDCDriver::D3D11, m_FrameCounter, flags);
+      rdcstr overlayText =
+          RenderDoc::Inst().GetOverlayText(RDCDriver::D3D11, devWnd, m_FrameCounter, 0);
 
       if(activeWindow && m_FailedFrame > 0)
       {
@@ -2671,12 +2674,12 @@ HRESULT WrappedID3D11Device::Present(IDXGISwapper *swapper, UINT SyncInterval, U
   // kill any current capture that isn't application defined
   if(IsActiveCapturing(m_State) && !m_AppControlledCapture)
   {
-    RenderDoc::Inst().EndFrameCapture((ID3D11Device *)this, swapper->GetHWND());
+    RenderDoc::Inst().EndFrameCapture(devWnd);
   }
 
   if(IsBackgroundCapturing(m_State) && RenderDoc::Inst().ShouldTriggerCapture(m_FrameCounter))
   {
-    RenderDoc::Inst().StartFrameCapture((ID3D11Device *)this, swapper->GetHWND());
+    RenderDoc::Inst().StartFrameCapture(devWnd);
 
     m_AppControlledCapture = false;
     m_CapturedFrames.back().frameNumber = m_FrameCounter;
diff --git a/renderdoc/driver/d3d11/d3d11_device.h b/renderdoc/driver/d3d11/d3d11_device.h
index 79eb6c468..d5c64c7bc 100644
--- a/renderdoc/driver/d3d11/d3d11_device.h
+++ b/renderdoc/driver/d3d11/d3d11_device.h
@@ -697,9 +697,9 @@ public:
   bool Serialise_CaptureScope(SerialiserType &ser);
 
   RDCDriver GetFrameCaptureDriver() { return RDCDriver::D3D11; }
-  void StartFrameCapture(void *dev, void *wnd);
-  bool EndFrameCapture(void *dev, void *wnd);
-  bool DiscardFrameCapture(void *dev, void *wnd);
+  void StartFrameCapture(DeviceOwnedWindow devWnd);
+  bool EndFrameCapture(DeviceOwnedWindow devWnd);
+  bool DiscardFrameCapture(DeviceOwnedWindow devWnd);
 
   ID3DUserDefinedAnnotation *GetAnnotations() { return m_RealAnnotations; }
   ID3D11InfoQueue *GetInfoQueue() { return m_pInfoQueue; }
diff --git a/renderdoc/driver/d3d12/d3d12_command_queue_wrap.cpp b/renderdoc/driver/d3d12/d3d12_command_queue_wrap.cpp
index 95732193f..eaed42f37 100644
--- a/renderdoc/driver/d3d12/d3d12_command_queue_wrap.cpp
+++ b/renderdoc/driver/d3d12/d3d12_command_queue_wrap.cpp
@@ -1341,13 +1341,15 @@ HRESULT STDMETHODCALLTYPE WrappedID3D12CommandQueue::Present(
     if(m_pPresentHWND != NULL)
     {
       Keyboard::RemoveInputWindow(WindowingSystem::Win32, m_pPresentHWND);
-      RenderDoc::Inst().RemoveFrameCapturer(m_pDevice->GetFrameCapturerDevice(), m_pPresentHWND);
+      RenderDoc::Inst().RemoveFrameCapturer(
+          DeviceOwnedWindow(m_pDevice->GetFrameCapturerDevice(), m_pPresentHWND));
     }
 
     Keyboard::AddInputWindow(WindowingSystem::Win32, hWindow);
 
-    RenderDoc::Inst().AddFrameCapturer(m_pDevice->GetFrameCapturerDevice(), hWindow,
-                                       m_pDevice->GetFrameCapturer());
+    RenderDoc::Inst().AddFrameCapturer(
+        DeviceOwnedWindow(m_pDevice->GetFrameCapturerDevice(), hWindow),
+        m_pDevice->GetFrameCapturer());
   }
 
   m_pPresentSource = pSourceTex2D;
diff --git a/renderdoc/driver/d3d12/d3d12_device.cpp b/renderdoc/driver/d3d12/d3d12_device.cpp
index c416d7cb0..021b4cacc 100644
--- a/renderdoc/driver/d3d12/d3d12_device.cpp
+++ b/renderdoc/driver/d3d12/d3d12_device.cpp
@@ -226,13 +226,14 @@ void STDMETHODCALLTYPE WrappedID3D12SharingContract::Present(_In_ ID3D12Resource
     if(m_pPresentHWND != NULL)
     {
       Keyboard::RemoveInputWindow(WindowingSystem::Win32, m_pPresentHWND);
-      RenderDoc::Inst().RemoveFrameCapturer(m_pDevice.GetFrameCapturerDevice(), m_pPresentHWND);
+      RenderDoc::Inst().RemoveFrameCapturer(
+          DeviceOwnedWindow(m_pDevice.GetFrameCapturerDevice(), m_pPresentHWND));
     }
 
     Keyboard::AddInputWindow(WindowingSystem::Win32, window);
 
-    RenderDoc::Inst().AddFrameCapturer(m_pDevice.GetFrameCapturerDevice(), window,
-                                       m_pDevice.GetFrameCapturer());
+    RenderDoc::Inst().AddFrameCapturer(
+        DeviceOwnedWindow(m_pDevice.GetFrameCapturerDevice(), window), m_pDevice.GetFrameCapturer());
   }
 
   m_pPresentSource = pResource;
@@ -1383,7 +1384,8 @@ void WrappedID3D12Device::FirstFrame(IDXGISwapper *swapper)
   // if we have to capture the first frame, begin capturing immediately
   if(IsBackgroundCapturing(m_State) && RenderDoc::Inst().ShouldTriggerCapture(0))
   {
-    RenderDoc::Inst().StartFrameCapture((ID3D12Device *)this, swapper ? swapper->GetHWND() : NULL);
+    RenderDoc::Inst().StartFrameCapture(
+        DeviceOwnedWindow((ID3D12Device *)this, swapper ? swapper->GetHWND() : NULL));
 
     m_AppControlledCapture = false;
     m_CapturedFrames.back().frameNumber = 0;
@@ -2034,7 +2036,9 @@ HRESULT WrappedID3D12Device::Present(ID3D12GraphicsCommandList *pOverlayCommandL
 
   m_FrameCounter++;    // first present becomes frame #1, this function is at the end of the frame
 
-  bool activeWindow = RenderDoc::Inst().IsActiveWindow((ID3D12Device *)this, swapper->GetHWND());
+  DeviceOwnedWindow devWnd((ID3D12Device *)this, swapper->GetHWND());
+
+  bool activeWindow = RenderDoc::Inst().IsActiveWindow(devWnd);
 
   m_LastSwap = swapper;
 
@@ -2073,9 +2077,8 @@ HRESULT WrappedID3D12Device::Present(ID3D12GraphicsCommandList *pOverlayCommandL
 
         list->OMSetRenderTargets(1, &rtv, FALSE, NULL);
 
-        int flags = activeWindow ? RenderDoc::eOverlay_ActiveWindow : 0;
         rdcstr overlayText =
-            RenderDoc::Inst().GetOverlayText(RDCDriver::D3D12, m_FrameCounter, flags);
+            RenderDoc::Inst().GetOverlayText(RDCDriver::D3D12, devWnd, m_FrameCounter, 0);
 
         m_TextRenderer->RenderText(list, 0.0f, 0.0f, overlayText);
 
@@ -2119,11 +2122,11 @@ HRESULT WrappedID3D12Device::Present(ID3D12GraphicsCommandList *pOverlayCommandL
 
   // kill any current capture that isn't application defined
   if(IsActiveCapturing(m_State) && !m_AppControlledCapture)
-    RenderDoc::Inst().EndFrameCapture((ID3D12Device *)this, swapper->GetHWND());
+    RenderDoc::Inst().EndFrameCapture(devWnd);
 
   if(IsBackgroundCapturing(m_State) && RenderDoc::Inst().ShouldTriggerCapture(m_FrameCounter))
   {
-    RenderDoc::Inst().StartFrameCapture((ID3D12Device *)this, swapper->GetHWND());
+    RenderDoc::Inst().StartFrameCapture(devWnd);
 
     m_AppControlledCapture = false;
     m_CapturedFrames.back().frameNumber = m_FrameCounter;
@@ -2242,7 +2245,7 @@ void WrappedID3D12Device::EndCaptureFrame()
   m_FrameCaptureRecord->AddChunk(scope.Get());
 }
 
-void WrappedID3D12Device::StartFrameCapture(void *dev, void *wnd)
+void WrappedID3D12Device::StartFrameCapture(DeviceOwnedWindow devWnd)
 {
   if(!IsBackgroundCapturing(m_State))
     return;
@@ -2328,7 +2331,7 @@ void WrappedID3D12Device::StartFrameCapture(void *dev, void *wnd)
   GetResourceManager()->MarkResourceFrameReferenced(m_ResourceID, eFrameRef_Read);
 }
 
-bool WrappedID3D12Device::EndFrameCapture(void *dev, void *wnd)
+bool WrappedID3D12Device::EndFrameCapture(DeviceOwnedWindow devWnd)
 {
   if(!IsActiveCapturing(m_State))
     return true;
@@ -2336,11 +2339,11 @@ bool WrappedID3D12Device::EndFrameCapture(void *dev, void *wnd)
   IDXGISwapper *swapper = NULL;
   SwapPresentInfo swapInfo = {};
 
-  if(wnd)
+  if(devWnd.windowHandle)
   {
     for(auto it = m_SwapChains.begin(); it != m_SwapChains.end(); ++it)
     {
-      if(it->first->GetHWND() == wnd)
+      if(it->first->GetHWND() == devWnd.windowHandle)
       {
         swapper = it->first;
         swapInfo = it->second;
@@ -2350,7 +2353,8 @@ bool WrappedID3D12Device::EndFrameCapture(void *dev, void *wnd)
 
     if(swapper == NULL)
     {
-      RDCERR("Output window %p provided for frame capture corresponds with no known swap chain", wnd);
+      RDCERR("Output window %p provided for frame capture corresponds with no known swap chain",
+             devWnd.windowHandle);
       return false;
     }
   }
@@ -2720,7 +2724,7 @@ bool WrappedID3D12Device::EndFrameCapture(void *dev, void *wnd)
   return true;
 }
 
-bool WrappedID3D12Device::DiscardFrameCapture(void *dev, void *wnd)
+bool WrappedID3D12Device::DiscardFrameCapture(DeviceOwnedWindow devWnd)
 {
   if(!IsActiveCapturing(m_State))
     return true;
diff --git a/renderdoc/driver/d3d12/d3d12_device.h b/renderdoc/driver/d3d12/d3d12_device.h
index b948ea19c..926d49edd 100644
--- a/renderdoc/driver/d3d12/d3d12_device.h
+++ b/renderdoc/driver/d3d12/d3d12_device.h
@@ -914,9 +914,9 @@ public:
   void GPUSyncAllQueues();
 
   RDCDriver GetFrameCaptureDriver() { return RDCDriver::D3D12; }
-  void StartFrameCapture(void *dev, void *wnd);
-  bool EndFrameCapture(void *dev, void *wnd);
-  bool DiscardFrameCapture(void *dev, void *wnd);
+  void StartFrameCapture(DeviceOwnedWindow devWnd);
+  bool EndFrameCapture(DeviceOwnedWindow devWnd);
+  bool DiscardFrameCapture(DeviceOwnedWindow devWnd);
 
   template <typename SerialiserType>
   bool Serialise_Present(SerialiserType &ser, ID3D12Resource *PresentedImage, UINT SyncInterval,
diff --git a/renderdoc/driver/d3d8/d3d8_device.cpp b/renderdoc/driver/d3d8/d3d8_device.cpp
index 6c9781568..7effac3c9 100644
--- a/renderdoc/driver/d3d8/d3d8_device.cpp
+++ b/renderdoc/driver/d3d8/d3d8_device.cpp
@@ -52,7 +52,7 @@ WrappedD3DDevice8::WrappedD3DDevice8(IDirect3DDevice8 *device, HWND wnd,
     m_Wnd = wnd;
 
     if(wnd != NULL)
-      RenderDoc::Inst().AddFrameCapturer((IDirect3DDevice8 *)this, wnd, this);
+      RenderDoc::Inst().AddFrameCapturer(DeviceOwnedWindow((IDirect3DDevice8 *)this, wnd), this);
   }
   else
   {
@@ -86,7 +86,7 @@ WrappedD3DDevice8::~WrappedD3DDevice8()
   RenderDoc::Inst().RemoveDeviceFrameCapturer((IDirect3DDevice8 *)this);
 
   if(m_Wnd != NULL)
-    RenderDoc::Inst().RemoveFrameCapturer((IDirect3DDevice8 *)this, m_Wnd);
+    RenderDoc::Inst().RemoveFrameCapturer(DeviceOwnedWindow((IDirect3DDevice8 *)this, m_Wnd));
 
   SAFE_DELETE(m_DebugManager);
 
@@ -149,18 +149,18 @@ void WrappedD3DDevice8::LazyInit()
   m_DebugManager = new D3D8DebugManager(this);
 }
 
-void WrappedD3DDevice8::StartFrameCapture(void *dev, void *wnd)
+void WrappedD3DDevice8::StartFrameCapture(DeviceOwnedWindow devWnd)
 {
   RDCERR("Capture not supported on D3D8");
 }
 
-bool WrappedD3DDevice8::EndFrameCapture(void *dev, void *wnd)
+bool WrappedD3DDevice8::EndFrameCapture(DeviceOwnedWindow devWnd)
 {
   RDCERR("Capture not supported on D3D8");
   return false;
 }
 
-bool WrappedD3DDevice8::DiscardFrameCapture(void *dev, void *wnd)
+bool WrappedD3DDevice8::DiscardFrameCapture(DeviceOwnedWindow devWnd)
 {
   RDCERR("Capture not supported on D3D8");
   return false;
@@ -239,7 +239,7 @@ HRESULT __stdcall WrappedD3DDevice8::Present(CONST RECT *pSourceRect, CONST RECT
   if(hDestWindowOverride != NULL)
     wnd = hDestWindowOverride;
 
-  bool activeWindow = RenderDoc::Inst().IsActiveWindow((IDirect3DDevice8 *)this, wnd);
+  DeviceOwnedWindow devWnd((IDirect3DDevice8 *)this, wnd);
 
   m_FrameCounter++;
 
@@ -270,10 +270,8 @@ HRESULT __stdcall WrappedD3DDevice8::Present(CONST RECT *pSourceRect, CONST RECT
       GetDebugManager()->SetOutputDimensions(bbDesc.Width, bbDesc.Height);
       GetDebugManager()->SetOutputWindow(m_PresentParameters.hDeviceWindow);
 
-      int flags = activeWindow ? RenderDoc::eOverlay_ActiveWindow : 0;
-      flags |= RenderDoc::eOverlay_CaptureDisabled;
-
-      rdcstr overlayText = RenderDoc::Inst().GetOverlayText(RDCDriver::D3D8, m_FrameCounter, flags);
+      rdcstr overlayText = RenderDoc::Inst().GetOverlayText(RDCDriver::D3D8, devWnd, m_FrameCounter,
+                                                            RenderDoc::eOverlay_CaptureDisabled);
 
       overlayText += "Captures not supported with D3D8\n";
 
diff --git a/renderdoc/driver/d3d8/d3d8_device.h b/renderdoc/driver/d3d8/d3d8_device.h
index c91704d73..8a8b1f410 100644
--- a/renderdoc/driver/d3d8/d3d8_device.h
+++ b/renderdoc/driver/d3d8/d3d8_device.h
@@ -39,9 +39,9 @@ public:
   void LazyInit();
 
   RDCDriver GetFrameCaptureDriver() { return RDCDriver::D3D8; }
-  void StartFrameCapture(void *dev, void *wnd);
-  bool EndFrameCapture(void *dev, void *wnd);
-  bool DiscardFrameCapture(void *dev, void *wnd);
+  void StartFrameCapture(DeviceOwnedWindow devWnd);
+  bool EndFrameCapture(DeviceOwnedWindow devWnd);
+  bool DiscardFrameCapture(DeviceOwnedWindow devWnd);
 
   void InternalRef() { InterlockedIncrement(&m_InternalRefcount); }
   void InternalRelease() { InterlockedDecrement(&m_InternalRefcount); }
diff --git a/renderdoc/driver/d3d9/d3d9_device.cpp b/renderdoc/driver/d3d9/d3d9_device.cpp
index 3ddd7aed6..ac54065e1 100644
--- a/renderdoc/driver/d3d9/d3d9_device.cpp
+++ b/renderdoc/driver/d3d9/d3d9_device.cpp
@@ -47,7 +47,7 @@ WrappedD3DDevice9::WrappedD3DDevice9(IDirect3DDevice9 *device, HWND wnd)
     m_Wnd = wnd;
 
     if(wnd != NULL)
-      RenderDoc::Inst().AddFrameCapturer((IDirect3DDevice9 *)this, wnd, this);
+      RenderDoc::Inst().AddFrameCapturer(DeviceOwnedWindow((IDirect3DDevice9 *)this, wnd), this);
   }
   else
   {
@@ -77,7 +77,7 @@ WrappedD3DDevice9::~WrappedD3DDevice9()
   RenderDoc::Inst().RemoveDeviceFrameCapturer((IDirect3DDevice9 *)this);
 
   if(m_Wnd != NULL)
-    RenderDoc::Inst().RemoveFrameCapturer((IDirect3DDevice9 *)this, m_Wnd);
+    RenderDoc::Inst().RemoveFrameCapturer(DeviceOwnedWindow((IDirect3DDevice9 *)this, m_Wnd));
 
   SAFE_DELETE(m_DebugManager);
 
@@ -109,18 +109,18 @@ void WrappedD3DDevice9::LazyInit()
   m_DebugManager = new D3D9DebugManager(this);
 }
 
-void WrappedD3DDevice9::StartFrameCapture(void *dev, void *wnd)
+void WrappedD3DDevice9::StartFrameCapture(DeviceOwnedWindow wnd)
 {
   RDCERR("Capture not supported on D3D9");
 }
 
-bool WrappedD3DDevice9::EndFrameCapture(void *dev, void *wnd)
+bool WrappedD3DDevice9::EndFrameCapture(DeviceOwnedWindow wnd)
 {
   RDCERR("Capture not supported on D3D9");
   return false;
 }
 
-bool WrappedD3DDevice9::DiscardFrameCapture(void *dev, void *wnd)
+bool WrappedD3DDevice9::DiscardFrameCapture(DeviceOwnedWindow wnd)
 {
   RDCERR("Capture not supported on D3D9");
   return false;
@@ -214,7 +214,7 @@ HRESULT __stdcall WrappedD3DDevice9::Present(CONST RECT *pSourceRect, CONST RECT
   if(hDestWindowOverride != NULL)
     wnd = hDestWindowOverride;
 
-  bool activeWindow = RenderDoc::Inst().IsActiveWindow((IDirect3DDevice9 *)this, wnd);
+  DeviceOwnedWindow devWnd((IDirect3DDevice9 *)this, wnd);
 
   m_FrameCounter++;
 
@@ -244,10 +244,8 @@ HRESULT __stdcall WrappedD3DDevice9::Present(CONST RECT *pSourceRect, CONST RECT
       GetDebugManager()->SetOutputDimensions(bbDesc.Width, bbDesc.Height);
       GetDebugManager()->SetOutputWindow(presentParams.hDeviceWindow);
 
-      int flags = activeWindow ? RenderDoc::eOverlay_ActiveWindow : 0;
-      flags |= RenderDoc::eOverlay_CaptureDisabled;
-
-      rdcstr overlayText = RenderDoc::Inst().GetOverlayText(RDCDriver::D3D9, m_FrameCounter, flags);
+      rdcstr overlayText = RenderDoc::Inst().GetOverlayText(RDCDriver::D3D9, devWnd, m_FrameCounter,
+                                                            RenderDoc::eOverlay_CaptureDisabled);
 
       overlayText += "Captures not supported with D3D9\n";
 
diff --git a/renderdoc/driver/d3d9/d3d9_device.h b/renderdoc/driver/d3d9/d3d9_device.h
index 846a3e6d9..6cf5799e7 100644
--- a/renderdoc/driver/d3d9/d3d9_device.h
+++ b/renderdoc/driver/d3d9/d3d9_device.h
@@ -37,9 +37,9 @@ public:
   void LazyInit();
 
   RDCDriver GetFrameCaptureDriver() { return RDCDriver::D3D9; }
-  void StartFrameCapture(void *dev, void *wnd);
-  bool EndFrameCapture(void *dev, void *wnd);
-  bool DiscardFrameCapture(void *dev, void *wnd);
+  void StartFrameCapture(DeviceOwnedWindow devWnd);
+  bool EndFrameCapture(DeviceOwnedWindow devWnd);
+  bool DiscardFrameCapture(DeviceOwnedWindow devWnd);
 
   void InternalRef() { InterlockedIncrement(&m_InternalRefcount); }
   void InternalRelease() { InterlockedDecrement(&m_InternalRefcount); }
diff --git a/renderdoc/driver/dxgi/dxgi_hooks.cpp b/renderdoc/driver/dxgi/dxgi_hooks.cpp
index b13c5a96a..5e35b8289 100644
--- a/renderdoc/driver/dxgi/dxgi_hooks.cpp
+++ b/renderdoc/driver/dxgi/dxgi_hooks.cpp
@@ -54,18 +54,18 @@ struct RenderDocAnalysis : IDXGraphicsAnalysis
   // IDXGraphicsAnalysis
   void STDMETHODCALLTYPE BeginCapture()
   {
-    void *dev = NULL, *wnd = NULL;
-    RenderDoc::Inst().GetActiveWindow(dev, wnd);
+    DeviceOwnedWindow devWnd;
+    RenderDoc::Inst().GetActiveWindow(devWnd);
 
-    RenderDoc::Inst().StartFrameCapture(dev, wnd);
+    RenderDoc::Inst().StartFrameCapture(devWnd);
   }
 
   void STDMETHODCALLTYPE EndCapture()
   {
-    void *dev = NULL, *wnd = NULL;
-    RenderDoc::Inst().GetActiveWindow(dev, wnd);
+    DeviceOwnedWindow devWnd;
+    RenderDoc::Inst().GetActiveWindow(devWnd);
 
-    RenderDoc::Inst().EndFrameCapture(dev, wnd);
+    RenderDoc::Inst().EndFrameCapture(devWnd);
   }
 };
 
diff --git a/renderdoc/driver/dxgi/dxgi_wrapped.cpp b/renderdoc/driver/dxgi/dxgi_wrapped.cpp
index f9ab49ff2..ed400fdc2 100644
--- a/renderdoc/driver/dxgi/dxgi_wrapped.cpp
+++ b/renderdoc/driver/dxgi/dxgi_wrapped.cpp
@@ -237,7 +237,7 @@ WrappedIDXGISwapChain4::WrappedIDXGISwapChain4(IDXGISwapChain *real, HWND w, ID3
   {
     Keyboard::AddInputWindow(WindowingSystem::Win32, wnd);
 
-    RenderDoc::Inst().AddFrameCapturer(m_pDevice->GetFrameCapturerDevice(), wnd,
+    RenderDoc::Inst().AddFrameCapturer(DeviceOwnedWindow(m_pDevice->GetFrameCapturerDevice(), wnd),
                                        m_pDevice->GetFrameCapturer());
   }
 
@@ -254,7 +254,7 @@ WrappedIDXGISwapChain4::~WrappedIDXGISwapChain4()
   {
     Keyboard::RemoveInputWindow(WindowingSystem::Win32, wnd);
 
-    RenderDoc::Inst().RemoveFrameCapturer(m_pDevice->GetFrameCapturerDevice(), wnd);
+    RenderDoc::Inst().RemoveFrameCapturer(DeviceOwnedWindow(m_pDevice->GetFrameCapturerDevice(), wnd));
   }
 
   m_pDevice->ReleaseSwapchainResources(this, 0, NULL, NULL);
diff --git a/renderdoc/driver/gl/gl_driver.cpp b/renderdoc/driver/gl/gl_driver.cpp
index c40278213..2fd6d5768 100644
--- a/renderdoc/driver/gl/gl_driver.cpp
+++ b/renderdoc/driver/gl/gl_driver.cpp
@@ -1133,7 +1133,7 @@ void WrappedOpenGL::ContextData::UnassociateWindow(WrappedOpenGL *driver, void *
       Keyboard::RemoveInputWindow(it->second.first, wndHandle);
 
     windows.erase(wndHandle);
-    RenderDoc::Inst().RemoveFrameCapturer(ctx, wndHandle);
+    RenderDoc::Inst().RemoveFrameCapturer(DeviceOwnedWindow(ctx, wndHandle));
   }
 }
 
@@ -1143,7 +1143,7 @@ void WrappedOpenGL::ContextData::AssociateWindow(WrappedOpenGL *driver, Windowin
   auto it = windows.find(wndHandle);
   if(it == windows.end())
   {
-    RenderDoc::Inst().AddFrameCapturer(ctx, wndHandle, driver);
+    RenderDoc::Inst().AddFrameCapturer(DeviceOwnedWindow(ctx, wndHandle), driver);
 
     if(winSystem != WindowingSystem::Headless && IsCaptureMode(driver->GetState()))
       Keyboard::AddInputWindow(winSystem, wndHandle);
@@ -2013,7 +2013,9 @@ void WrappedOpenGL::SwapBuffers(WindowingSystem winSystem, void *windowHandle)
   if(!ctxdata.ready)
     ctxdata.CreateDebugData();
 
-  bool activeWindow = RenderDoc::Inst().IsActiveWindow(ctxdata.ctx, windowHandle);
+  DeviceOwnedWindow devWnd(ctxdata.ctx, windowHandle);
+
+  bool activeWindow = RenderDoc::Inst().IsActiveWindow(devWnd);
 
   // look at previous associations and decay any that are too old
   uint64_t ref = Timing::GetUnixTimestamp() - 5;    // 5 seconds
@@ -2042,11 +2044,12 @@ void WrappedOpenGL::SwapBuffers(WindowingSystem winSystem, void *windowHandle)
 
     if(overlay & eRENDERDOC_Overlay_Enabled)
     {
-      int flags = activeWindow ? RenderDoc::eOverlay_ActiveWindow : 0;
+      int flags = 0;
       // capturing is disabled if unsupported functions have been used, or this context is legacy
       if(ctxdata.Legacy() || !m_UnsupportedFunctions.empty())
         flags |= RenderDoc::eOverlay_CaptureDisabled;
-      rdcstr overlayText = RenderDoc::Inst().GetOverlayText(GetDriverType(), m_FrameCounter, flags);
+      rdcstr overlayText =
+          RenderDoc::Inst().GetOverlayText(GetDriverType(), devWnd, m_FrameCounter, flags);
 
       if(ctxdata.Legacy())
       {
@@ -2132,11 +2135,11 @@ void WrappedOpenGL::SwapBuffers(WindowingSystem winSystem, void *windowHandle)
 
   // kill any current capture that isn't application defined
   if(IsActiveCapturing(m_State) && !m_AppControlledCapture)
-    RenderDoc::Inst().EndFrameCapture(ctxdata.ctx, windowHandle);
+    RenderDoc::Inst().EndFrameCapture(devWnd);
 
   if(RenderDoc::Inst().ShouldTriggerCapture(m_FrameCounter) && IsBackgroundCapturing(m_State))
   {
-    RenderDoc::Inst().StartFrameCapture(ctxdata.ctx, windowHandle);
+    RenderDoc::Inst().StartFrameCapture(devWnd);
 
     m_AppControlledCapture = false;
     m_CapturedFrames.back().frameNumber = m_FrameCounter;
@@ -2169,7 +2172,7 @@ GLWindowingData *WrappedOpenGL::MakeValidContextCurrent(GLWindowingData existing
   return NULL;
 }
 
-void WrappedOpenGL::StartFrameCapture(void *dev, void *wnd)
+void WrappedOpenGL::StartFrameCapture(DeviceOwnedWindow devWnd)
 {
   if(!IsBackgroundCapturing(m_State))
     return;
@@ -2230,7 +2233,7 @@ void WrappedOpenGL::StartFrameCapture(void *dev, void *wnd)
   }
 }
 
-bool WrappedOpenGL::EndFrameCapture(void *dev, void *wnd)
+bool WrappedOpenGL::EndFrameCapture(DeviceOwnedWindow devWnd)
 {
   if(!IsActiveCapturing(m_State))
     return true;
@@ -2258,9 +2261,10 @@ bool WrappedOpenGL::EndFrameCapture(void *dev, void *wnd)
 
     // if the specified context isn't current, try and see if we've saved
     // an appropriate backbuffer image during capture.
-    if((dev != NULL && existing.ctx != dev) || (wnd != 0 && (void *)existing.wnd != wnd))
+    if((devWnd.device != NULL && existing.ctx != devWnd.device) ||
+       (devWnd.windowHandle != 0 && (void *)existing.wnd != devWnd.windowHandle))
     {
-      auto it = m_BackbufferImages.find(wnd);
+      auto it = m_BackbufferImages.find(devWnd.windowHandle);
       if(it != m_BackbufferImages.end())
       {
         // pop this backbuffer image out of the map
@@ -2532,7 +2536,7 @@ bool WrappedOpenGL::EndFrameCapture(void *dev, void *wnd)
   }
 }
 
-bool WrappedOpenGL::DiscardFrameCapture(void *dev, void *wnd)
+bool WrappedOpenGL::DiscardFrameCapture(DeviceOwnedWindow devWnd)
 {
   if(!IsActiveCapturing(m_State))
     return true;
@@ -2588,7 +2592,7 @@ void WrappedOpenGL::FirstFrame(void *ctx, void *wndHandle)
   {
     // since we haven't associated the window we can't capture by window, so we have to capture just
     // on the device - the very next present to any window on this context will end the capture.
-    RenderDoc::Inst().StartFrameCapture(ctx, NULL);
+    RenderDoc::Inst().StartFrameCapture(DeviceOwnedWindow(ctx, NULL));
 
     m_AppControlledCapture = false;
     m_CapturedFrames.back().frameNumber = 0;
diff --git a/renderdoc/driver/gl/gl_driver.h b/renderdoc/driver/gl/gl_driver.h
index 630263eb2..e65775691 100644
--- a/renderdoc/driver/gl/gl_driver.h
+++ b/renderdoc/driver/gl/gl_driver.h
@@ -696,9 +696,9 @@ public:
 
   void ReplayMarkers(bool replay) { m_ReplayMarkers = replay; }
   RDCDriver GetFrameCaptureDriver() { return GetDriverType(); }
-  void StartFrameCapture(void *dev, void *wnd);
-  bool EndFrameCapture(void *dev, void *wnd);
-  bool DiscardFrameCapture(void *dev, void *wnd);
+  void StartFrameCapture(DeviceOwnedWindow devWnd);
+  bool EndFrameCapture(DeviceOwnedWindow devWnd);
+  bool DiscardFrameCapture(DeviceOwnedWindow devWnd);
 
   // map with key being mip level, value being stored data
   typedef std::map<int, bytebuf> CompressedDataStore;
diff --git a/renderdoc/driver/vulkan/vk_core.cpp b/renderdoc/driver/vulkan/vk_core.cpp
index 901b8c85c..ee96409bf 100644
--- a/renderdoc/driver/vulkan/vk_core.cpp
+++ b/renderdoc/driver/vulkan/vk_core.cpp
@@ -1765,7 +1765,7 @@ void WrappedVulkan::FirstFrame()
   // if we have to capture the first frame, begin capturing immediately
   if(IsBackgroundCapturing(m_State) && RenderDoc::Inst().ShouldTriggerCapture(0))
   {
-    RenderDoc::Inst().StartFrameCapture(LayerDisp(m_Instance), NULL);
+    RenderDoc::Inst().StartFrameCapture(DeviceOwnedWindow(LayerDisp(m_Instance), NULL));
 
     m_AppControlledCapture = false;
     m_CapturedFrames.back().frameNumber = 0;
@@ -1789,7 +1789,7 @@ bool WrappedVulkan::Serialise_BeginCaptureFrame(SerialiserType &ser)
   return true;
 }
 
-void WrappedVulkan::StartFrameCapture(void *dev, void *wnd)
+void WrappedVulkan::StartFrameCapture(DeviceOwnedWindow devWnd)
 {
   if(!IsBackgroundCapturing(m_State))
     return;
@@ -1897,25 +1897,26 @@ void WrappedVulkan::StartFrameCapture(void *dev, void *wnd)
   }
 }
 
-bool WrappedVulkan::EndFrameCapture(void *dev, void *wnd)
+bool WrappedVulkan::EndFrameCapture(DeviceOwnedWindow devWnd)
 {
   if(!IsActiveCapturing(m_State))
     return true;
 
   VkSwapchainKHR swap = VK_NULL_HANDLE;
 
-  if(wnd)
+  if(devWnd.windowHandle)
   {
     {
       SCOPED_LOCK(m_SwapLookupLock);
-      auto it = m_SwapLookup.find(wnd);
+      auto it = m_SwapLookup.find(devWnd.windowHandle);
       if(it != m_SwapLookup.end())
         swap = it->second;
     }
 
     if(swap == VK_NULL_HANDLE)
     {
-      RDCERR("Output window %p provided for frame capture corresponds with no known swap chain", wnd);
+      RDCERR("Output window %p provided for frame capture corresponds with no known swap chain",
+             devWnd.windowHandle);
       return false;
     }
   }
@@ -2356,7 +2357,7 @@ bool WrappedVulkan::EndFrameCapture(void *dev, void *wnd)
   return true;
 }
 
-bool WrappedVulkan::DiscardFrameCapture(void *dev, void *wnd)
+bool WrappedVulkan::DiscardFrameCapture(DeviceOwnedWindow devWnd)
 {
   if(!IsActiveCapturing(m_State))
     return true;
@@ -2418,9 +2419,9 @@ void WrappedVulkan::AdvanceFrame()
   m_FrameCounter++;    // first present becomes frame #1, this function is at the end of the frame
 }
 
-void WrappedVulkan::Present(void *dev, void *wnd)
+void WrappedVulkan::Present(DeviceOwnedWindow devWnd)
 {
-  bool activeWindow = wnd == NULL || RenderDoc::Inst().IsActiveWindow(dev, wnd);
+  bool activeWindow = devWnd.windowHandle == NULL || RenderDoc::Inst().IsActiveWindow(devWnd);
 
   RenderDoc::Inst().AddActiveDriver(RDCDriver::Vulkan, true);
 
@@ -2428,11 +2429,11 @@ void WrappedVulkan::Present(void *dev, void *wnd)
     return;
 
   if(IsActiveCapturing(m_State) && !m_AppControlledCapture)
-    RenderDoc::Inst().EndFrameCapture(dev, wnd);
+    RenderDoc::Inst().EndFrameCapture(devWnd);
 
   if(RenderDoc::Inst().ShouldTriggerCapture(m_FrameCounter) && IsBackgroundCapturing(m_State))
   {
-    RenderDoc::Inst().StartFrameCapture(dev, wnd);
+    RenderDoc::Inst().StartFrameCapture(devWnd);
 
     m_AppControlledCapture = false;
     m_CapturedFrames.back().frameNumber = m_FrameCounter;
@@ -2468,11 +2469,11 @@ void WrappedVulkan::HandleFrameMarkers(const char *marker, VkQueue queue)
 
   if(strstr(marker, "capture-marker,begin_capture") != NULL)
   {
-    RenderDoc::Inst().StartFrameCapture(LayerDisp(m_Instance), NULL);
+    RenderDoc::Inst().StartFrameCapture(DeviceOwnedWindow(LayerDisp(m_Instance), NULL));
   }
   if(strstr(marker, "capture-marker,end_capture") != NULL)
   {
-    RenderDoc::Inst().EndFrameCapture(LayerDisp(m_Instance), NULL);
+    RenderDoc::Inst().EndFrameCapture(DeviceOwnedWindow(LayerDisp(m_Instance), NULL));
   }
 }
 
@@ -3736,7 +3737,7 @@ VkResourceRecord *WrappedVulkan::RegisterSurface(WindowingSystem system, void *h
 {
   Keyboard::AddInputWindow(system, handle);
 
-  RenderDoc::Inst().AddFrameCapturer(LayerDisp(m_Instance), handle, this);
+  RenderDoc::Inst().AddFrameCapturer(DeviceOwnedWindow(LayerDisp(m_Instance), handle), this);
 
   return (VkResourceRecord *)new PackedWindowHandle(system, handle);
 }
diff --git a/renderdoc/driver/vulkan/vk_core.h b/renderdoc/driver/vulkan/vk_core.h
index 073cfe896..97dbf2af2 100644
--- a/renderdoc/driver/vulkan/vk_core.h
+++ b/renderdoc/driver/vulkan/vk_core.h
@@ -918,12 +918,12 @@ private:
   bool IsDrawInRenderPass();
 
   RDCDriver GetFrameCaptureDriver() { return RDCDriver::Vulkan; }
-  void StartFrameCapture(void *dev, void *wnd);
-  bool EndFrameCapture(void *dev, void *wnd);
-  bool DiscardFrameCapture(void *dev, void *wnd);
+  void StartFrameCapture(DeviceOwnedWindow devWnd);
+  bool EndFrameCapture(DeviceOwnedWindow devWnd);
+  bool DiscardFrameCapture(DeviceOwnedWindow devWnd);
 
   void AdvanceFrame();
-  void Present(void *dev, void *wnd);
+  void Present(DeviceOwnedWindow devWnd);
 
   void HandleFrameMarkers(const char *marker, VkCommandBuffer commandBuffer);
   void HandleFrameMarkers(const char *marker, VkQueue queue);
diff --git a/renderdoc/driver/vulkan/wrappers/vk_queue_funcs.cpp b/renderdoc/driver/vulkan/wrappers/vk_queue_funcs.cpp
index 90461a3c0..54136cb07 100644
--- a/renderdoc/driver/vulkan/wrappers/vk_queue_funcs.cpp
+++ b/renderdoc/driver/vulkan/wrappers/vk_queue_funcs.cpp
@@ -1337,7 +1337,7 @@ VkResult WrappedVulkan::vkQueueSubmit(VkQueue queue, uint32_t submitCount,
 
   if(beginCapture)
   {
-    RenderDoc::Inst().StartFrameCapture(LayerDisp(m_Instance), NULL);
+    RenderDoc::Inst().StartFrameCapture(DeviceOwnedWindow(LayerDisp(m_Instance), NULL));
   }
 
   {
@@ -1391,13 +1391,13 @@ VkResult WrappedVulkan::vkQueueSubmit(VkQueue queue, uint32_t submitCount,
 
   if(endCapture)
   {
-    RenderDoc::Inst().EndFrameCapture(LayerDisp(m_Instance), NULL);
+    RenderDoc::Inst().EndFrameCapture(DeviceOwnedWindow(LayerDisp(m_Instance), NULL));
   }
 
   if(present)
   {
     AdvanceFrame();
-    Present(LayerDisp(m_Instance), NULL);
+    Present(DeviceOwnedWindow(LayerDisp(m_Instance), NULL));
   }
 
   return ret;
@@ -1505,7 +1505,7 @@ VkResult WrappedVulkan::vkQueueSubmit2(VkQueue queue, uint32_t submitCount,
 
   if(beginCapture)
   {
-    RenderDoc::Inst().StartFrameCapture(LayerDisp(m_Instance), NULL);
+    RenderDoc::Inst().StartFrameCapture(DeviceOwnedWindow(LayerDisp(m_Instance), NULL));
   }
 
   {
@@ -1559,13 +1559,13 @@ VkResult WrappedVulkan::vkQueueSubmit2(VkQueue queue, uint32_t submitCount,
 
   if(endCapture)
   {
-    RenderDoc::Inst().EndFrameCapture(LayerDisp(m_Instance), NULL);
+    RenderDoc::Inst().EndFrameCapture(DeviceOwnedWindow(LayerDisp(m_Instance), NULL));
   }
 
   if(present)
   {
     AdvanceFrame();
-    Present(LayerDisp(m_Instance), NULL);
+    Present(DeviceOwnedWindow(LayerDisp(m_Instance), NULL));
   }
 
   return ret;
diff --git a/renderdoc/driver/vulkan/wrappers/vk_wsi_funcs.cpp b/renderdoc/driver/vulkan/wrappers/vk_wsi_funcs.cpp
index f627fc8f1..8c27b656f 100644
--- a/renderdoc/driver/vulkan/wrappers/vk_wsi_funcs.cpp
+++ b/renderdoc/driver/vulkan/wrappers/vk_wsi_funcs.cpp
@@ -730,8 +730,9 @@ bool WrappedVulkan::Serialise_vkQueuePresentKHR(SerialiserType &ser, VkQueue que
 
       SwapchainInfo &swapInfo = *swaprecord->swapInfo;
 
-      const bool activeWindow =
-          RenderDoc::Inst().IsActiveWindow(LayerDisp(m_Instance), swapInfo.wndHandle);
+      DeviceOwnedWindow devWnd(LayerDisp(m_Instance), swapInfo.wndHandle);
+
+      const bool activeWindow = RenderDoc::Inst().IsActiveWindow(devWnd);
 
       if(activeWindow || PresentedImage == ResourceId())
         PresentedImage = GetResID(swapInfo.images[pPresentInfo->pImageIndices[i]].im);
@@ -893,7 +894,7 @@ VkResult WrappedVulkan::vkQueuePresentKHR(VkQueue queue, const VkPresentInfoKHR
 
     SwapchainInfo &swapInfo = *swaprecord->swapInfo;
 
-    Present(LayerDisp(m_Instance), swapInfo.wndHandle);
+    Present(DeviceOwnedWindow(LayerDisp(m_Instance), swapInfo.wndHandle));
   }
 
   return vkr;
@@ -911,7 +912,9 @@ void WrappedVulkan::HandlePresent(VkQueue queue, const VkPresentInfoKHR *pPresen
 
   SwapchainInfo &swapInfo = *swaprecord->swapInfo;
 
-  bool activeWindow = RenderDoc::Inst().IsActiveWindow(LayerDisp(m_Instance), swapInfo.wndHandle);
+  DeviceOwnedWindow devWnd(LayerDisp(m_Instance), swapInfo.wndHandle);
+
+  const bool activeWindow = RenderDoc::Inst().IsActiveWindow(devWnd);
 
   // need to record which image was last flipped so we can get the correct backbuffer
   // for a thumbnail in EndFrameCapture
@@ -1057,8 +1060,8 @@ void WrappedVulkan::HandlePresent(VkQueue queue, const VkPresentInfoKHR *pPresen
             UnwrapPtr(m_ExternalQueues[swapQueueIndex].ring[ringIdx].toext);
       }
 
-      int flags = activeWindow ? RenderDoc::eOverlay_ActiveWindow : 0;
-      rdcstr overlayText = RenderDoc::Inst().GetOverlayText(RDCDriver::Vulkan, m_FrameCounter, flags);
+      rdcstr overlayText =
+          RenderDoc::Inst().GetOverlayText(RDCDriver::Vulkan, devWnd, m_FrameCounter, 0);
 
       if(!overlayText.empty())
       {
@@ -1145,7 +1148,7 @@ void WrappedVulkan::vkDestroySurfaceKHR(VkInstance instance, VkSurfaceKHR surfac
     PackedWindowHandle *wnd = (PackedWindowHandle *)wrapper->record;
     Keyboard::RemoveInputWindow(wnd->system, wnd->handle);
 
-    RenderDoc::Inst().RemoveFrameCapturer(LayerDisp(m_Instance), wnd->handle);
+    RenderDoc::Inst().RemoveFrameCapturer(DeviceOwnedWindow(LayerDisp(m_Instance), wnd->handle));
 
     delete wnd;
   }
diff --git a/renderdoc/replay/app_api.cpp b/renderdoc/replay/app_api.cpp
index 339043071..610c3269e 100644
--- a/renderdoc/replay/app_api.cpp
+++ b/renderdoc/replay/app_api.cpp
@@ -210,18 +210,20 @@ static uint32_t LaunchReplayUI(uint32_t connectTargetControl, const char *cmdlin
 
 static void SetActiveWindow(void *device, void *wndHandle)
 {
-  RenderDoc::Inst().SetActiveWindow(device, wndHandle);
+  RenderDoc::Inst().SetActiveWindow(DeviceOwnedWindow(device, wndHandle));
 }
 
 static void StartFrameCapture(void *device, void *wndHandle)
 {
-  RenderDoc::Inst().StartFrameCapture(device, wndHandle);
+  DeviceOwnedWindow devWnd(device, wndHandle);
 
-  if(device == NULL || wndHandle == NULL)
-    RenderDoc::Inst().MatchClosestWindow(device, wndHandle);
+  RenderDoc::Inst().StartFrameCapture(devWnd);
 
-  if(device != NULL && wndHandle != NULL)
-    RenderDoc::Inst().SetActiveWindow(device, wndHandle);
+  if(devWnd.device == NULL || devWnd.windowHandle == NULL)
+    RenderDoc::Inst().MatchClosestWindow(devWnd);
+
+  if(devWnd.device != NULL && devWnd.windowHandle != NULL)
+    RenderDoc::Inst().SetActiveWindow(devWnd);
 }
 
 static uint32_t IsFrameCapturing()
@@ -231,12 +233,12 @@ static uint32_t IsFrameCapturing()
 
 static uint32_t EndFrameCapture(void *device, void *wndHandle)
 {
-  return RenderDoc::Inst().EndFrameCapture(device, wndHandle) ? 1 : 0;
+  return RenderDoc::Inst().EndFrameCapture(DeviceOwnedWindow(device, wndHandle)) ? 1 : 0;
 }
 
 static uint32_t DiscardFrameCapture(void *device, void *wndHandle)
 {
-  return RenderDoc::Inst().DiscardFrameCapture(device, wndHandle) ? 1 : 0;
+  return RenderDoc::Inst().DiscardFrameCapture(DeviceOwnedWindow(device, wndHandle)) ? 1 : 0;
 }
 
 static uint32_t ShowReplayUI()