diff --git a/qrenderdoc/Code/Interface/QRDInterface.h b/qrenderdoc/Code/Interface/QRDInterface.h
index 6c50a55af..1cb850ed2 100644
--- a/qrenderdoc/Code/Interface/QRDInterface.h
+++ b/qrenderdoc/Code/Interface/QRDInterface.h
@@ -3375,7 +3375,7 @@ capture's API.
 
 protected:
   ICaptureContext() = default;
-  ~ICaptureContext() = default;
+  virtual ~ICaptureContext() = default;
 };
 
 DECLARE_REFLECTION_STRUCT(ICaptureContext);
diff --git a/qrenderdoc/Code/pyrenderdoc/PythonInvokers.cpp b/qrenderdoc/Code/pyrenderdoc/PythonInvokers.cpp
new file mode 100644
index 000000000..493b208f6
--- /dev/null
+++ b/qrenderdoc/Code/pyrenderdoc/PythonInvokers.cpp
@@ -0,0 +1,1830 @@
+/******************************************************************************
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2017-2026 Baldur Karlsson
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ ******************************************************************************/
+
+#include "Code/pyrenderdoc/PythonContext.h"
+#include "Windows/PythonShell.h"
+
+// a forwarder that invokes onto the UI thread wherever necessary.
+// Note this does NOT make CaptureContext thread safe. We just invoke for any potentially UI
+// operations. All invokes are blocking, so there can't be any times when the UI thread waits
+// on the python thread.
+template <typename Obj>
+struct UIThreadInvoker : Obj
+{
+  UIThreadInvoker(PythonShell *sh, Obj &o) : m_Shell(sh), m_Obj(o) {}
+  virtual ~UIThreadInvoker() {}
+  PythonShell *m_Shell;
+  Obj &m_Obj;
+
+  template <typename F, typename... paramTypes>
+  void InvokeVoidFunction(F ptr, paramTypes... params)
+  {
+    if(!GUIInvoke::onUIThread())
+    {
+      PythonContext *scriptContext = m_Shell->GetScriptContext();
+      if(scriptContext)
+        scriptContext->PausePythonThreading();
+      GUIInvoke::blockcall(m_Shell, [this, ptr, params...]() { (m_Obj.*ptr)(params...); });
+      if(scriptContext)
+        scriptContext->ResumePythonThreading();
+      return;
+    }
+
+    (m_Obj.*ptr)(params...);
+  }
+
+  template <typename R, typename F, typename... paramTypes>
+  R InvokeRetFunction(F ptr, paramTypes... params)
+  {
+    if(!GUIInvoke::onUIThread())
+    {
+      R ret;
+      PythonContext *scriptContext = m_Shell->GetScriptContext();
+      if(scriptContext)
+        scriptContext->PausePythonThreading();
+      GUIInvoke::blockcall(m_Shell,
+                           [this, &ret, ptr, params...]() { ret = (m_Obj.*ptr)(params...); });
+      if(scriptContext)
+        scriptContext->ResumePythonThreading();
+      return ret;
+    }
+
+    return (m_Obj.*ptr)(params...);
+  }
+};
+
+struct MiniQtInvoker : UIThreadInvoker<IMiniQtHelper>
+{
+  MiniQtInvoker(PythonShell *shell, IMiniQtHelper &obj) : UIThreadInvoker(shell, obj) {}
+  virtual ~MiniQtInvoker() {}
+  void InvokeOntoUIThread(std::function<void()> callback)
+  {
+    // this function is already thread safe since it's invoking, so just call it directly
+    m_Obj.InvokeOntoUIThread(callback);
+  }
+
+  ///////////////////////////////////////////////////////////////////////
+  // all functions invoke onto the UI thread since they deal with widgets!
+  ///////////////////////////////////////////////////////////////////////
+
+  QWidget *CreateToplevelWidget(const rdcstr &windowTitle, WidgetCallback closed)
+  {
+    return InvokeRetFunction<QWidget *>(&IMiniQtHelper::CreateToplevelWidget, windowTitle, closed);
+  }
+  void CloseToplevelWidget(QWidget *widget)
+  {
+    InvokeVoidFunction(&IMiniQtHelper::CloseToplevelWidget, widget);
+  }
+
+  // widget hierarchy
+
+  void SetWidgetName(QWidget *widget, const rdcstr &name)
+  {
+    InvokeVoidFunction(&IMiniQtHelper::SetWidgetName, widget, name);
+  }
+  rdcstr GetWidgetName(QWidget *widget)
+  {
+    return InvokeRetFunction<rdcstr>(&IMiniQtHelper::GetWidgetName, widget);
+  }
+  rdcstr GetWidgetType(QWidget *widget)
+  {
+    return InvokeRetFunction<rdcstr>(&IMiniQtHelper::GetWidgetType, widget);
+  }
+  QWidget *FindChildByName(QWidget *parent, const rdcstr &name)
+  {
+    return InvokeRetFunction<QWidget *>(&IMiniQtHelper::FindChildByName, parent, name);
+  }
+  QWidget *GetParent(QWidget *widget)
+  {
+    return InvokeRetFunction<QWidget *>(&IMiniQtHelper::GetParent, widget);
+  }
+  int32_t GetNumChildren(QWidget *widget)
+  {
+    return InvokeRetFunction<int32_t>(&IMiniQtHelper::GetNumChildren, widget);
+  }
+  QWidget *GetChild(QWidget *parent, int32_t index)
+  {
+    return InvokeRetFunction<QWidget *>(&IMiniQtHelper::GetChild, parent, index);
+  }
+  void DestroyWidget(QWidget *widget) { InvokeVoidFunction(&IMiniQtHelper::DestroyWidget, widget); }
+  // dialogs
+
+  bool ShowWidgetAsDialog(QWidget *widget)
+  {
+    return InvokeRetFunction<bool>(&IMiniQtHelper::ShowWidgetAsDialog, widget);
+  }
+  void CloseCurrentDialog(bool success)
+  {
+    InvokeVoidFunction(&IMiniQtHelper::CloseCurrentDialog, success);
+  }
+
+  // layout functions
+
+  QWidget *CreateHorizontalContainer()
+  {
+    return InvokeRetFunction<QWidget *>(&IMiniQtHelper::CreateHorizontalContainer);
+  }
+  QWidget *CreateVerticalContainer()
+  {
+    return InvokeRetFunction<QWidget *>(&IMiniQtHelper::CreateVerticalContainer);
+  }
+  QWidget *CreateGridContainer()
+  {
+    return InvokeRetFunction<QWidget *>(&IMiniQtHelper::CreateGridContainer);
+  }
+  QWidget *CreateSpacer(bool horizontal)
+  {
+    return InvokeRetFunction<QWidget *>(&IMiniQtHelper::CreateSpacer, horizontal);
+  }
+  void ClearContainedWidgets(QWidget *parent)
+  {
+    InvokeVoidFunction(&IMiniQtHelper::ClearContainedWidgets, parent);
+  }
+  void AddGridWidget(QWidget *parent, int32_t row, int32_t column, QWidget *child, int32_t rowSpan,
+                     int32_t columnSpan)
+  {
+    InvokeVoidFunction(&IMiniQtHelper::AddGridWidget, parent, row, column, child, rowSpan,
+                       columnSpan);
+  }
+  void AddWidget(QWidget *parent, QWidget *child)
+  {
+    InvokeVoidFunction(&IMiniQtHelper::AddWidget, parent, child);
+  }
+  void InsertWidget(QWidget *parent, int32_t index, QWidget *child)
+  {
+    InvokeVoidFunction(&IMiniQtHelper::InsertWidget, parent, index, child);
+  }
+
+  // widget manipulation
+
+  void SetWidgetText(QWidget *widget, const rdcstr &text)
+  {
+    InvokeVoidFunction(&IMiniQtHelper::SetWidgetText, widget, text);
+  }
+  rdcstr GetWidgetText(QWidget *widget)
+  {
+    return InvokeRetFunction<rdcstr>(&IMiniQtHelper::GetWidgetText, widget);
+  }
+
+  void SetWidgetFont(QWidget *widget, const rdcstr &font, int32_t fontSize, bool bold, bool italic)
+  {
+    InvokeVoidFunction(&IMiniQtHelper::SetWidgetFont, widget, font, fontSize, bold, italic);
+  }
+
+  void SetWidgetEnabled(QWidget *widget, bool enabled)
+  {
+    InvokeVoidFunction(&IMiniQtHelper::SetWidgetEnabled, widget, enabled);
+  }
+  bool IsWidgetEnabled(QWidget *widget)
+  {
+    return InvokeRetFunction<bool>(&IMiniQtHelper::IsWidgetEnabled, widget);
+  }
+  void SetWidgetVisible(QWidget *widget, bool visible)
+  {
+    InvokeVoidFunction(&IMiniQtHelper::SetWidgetVisible, widget, visible);
+  }
+  bool IsWidgetVisible(QWidget *widget)
+  {
+    return InvokeRetFunction<bool>(&IMiniQtHelper::IsWidgetVisible, widget);
+  }
+
+  // specific widgets
+
+  QWidget *CreateGroupBox(bool collapsible)
+  {
+    return InvokeRetFunction<QWidget *>(&IMiniQtHelper::CreateGroupBox, collapsible);
+  }
+
+  QWidget *CreateButton(WidgetCallback pressed)
+  {
+    return InvokeRetFunction<QWidget *>(&IMiniQtHelper::CreateButton, pressed);
+  }
+
+  QWidget *CreateLabel() { return InvokeRetFunction<QWidget *>(&IMiniQtHelper::CreateLabel); }
+  void SetLabelImage(QWidget *widget, const bytebuf &data, int32_t width, int32_t height, bool alpha)
+  {
+    InvokeVoidFunction(&IMiniQtHelper::SetLabelImage, widget, data, width, height, alpha);
+  }
+  QWidget *CreateOutputRenderingWidget()
+  {
+    return InvokeRetFunction<QWidget *>(&IMiniQtHelper::CreateOutputRenderingWidget);
+  }
+  WindowingData GetWidgetWindowingData(QWidget *widget)
+  {
+    return InvokeRetFunction<WindowingData>(&IMiniQtHelper::GetWidgetWindowingData, widget);
+  }
+
+  void SetWidgetReplayOutput(QWidget *widget, IReplayOutput *output)
+  {
+    InvokeVoidFunction(&IMiniQtHelper::SetWidgetReplayOutput, widget, output);
+  }
+
+  void SetWidgetBackgroundColor(QWidget *widget, float red, float green, float blue)
+  {
+    InvokeVoidFunction(&IMiniQtHelper::SetWidgetBackgroundColor, widget, red, green, blue);
+  }
+  QWidget *CreateCheckbox(WidgetCallback changed)
+  {
+    return InvokeRetFunction<QWidget *>(&IMiniQtHelper::CreateCheckbox, changed);
+  }
+  QWidget *CreateRadiobox(WidgetCallback changed)
+  {
+    return InvokeRetFunction<QWidget *>(&IMiniQtHelper::CreateRadiobox, changed);
+  }
+
+  void SetWidgetChecked(QWidget *checkableWidget, bool checked)
+  {
+    InvokeVoidFunction(&IMiniQtHelper::SetWidgetChecked, checkableWidget, checked);
+  }
+  bool IsWidgetChecked(QWidget *checkableWidget)
+  {
+    return InvokeRetFunction<bool>(&IMiniQtHelper::IsWidgetChecked, checkableWidget);
+  }
+
+  QWidget *CreateSpinbox(int32_t decimalPlaces, double step)
+  {
+    return InvokeRetFunction<QWidget *>(&IMiniQtHelper::CreateSpinbox, decimalPlaces, step);
+  }
+
+  void SetSpinboxBounds(QWidget *spinbox, double minVal, double maxVal)
+  {
+    InvokeVoidFunction(&IMiniQtHelper::SetSpinboxBounds, spinbox, minVal, maxVal);
+  }
+  void SetSpinboxValue(QWidget *spinbox, double value)
+  {
+    InvokeVoidFunction(&IMiniQtHelper::SetSpinboxValue, spinbox, value);
+  }
+  double GetSpinboxValue(QWidget *spinbox)
+  {
+    return InvokeRetFunction<double>(&IMiniQtHelper::GetSpinboxValue, spinbox);
+  }
+
+  QWidget *CreateTextBox(bool singleLine, WidgetCallback changed)
+  {
+    return InvokeRetFunction<QWidget *>(&IMiniQtHelper::CreateTextBox, singleLine, changed);
+  }
+
+  QWidget *CreateComboBox(bool editable, WidgetCallback changed)
+  {
+    return InvokeRetFunction<QWidget *>(&IMiniQtHelper::CreateComboBox, editable, changed);
+  }
+
+  void SetComboOptions(QWidget *combo, const rdcarray<rdcstr> &options)
+  {
+    InvokeVoidFunction(&IMiniQtHelper::SetComboOptions, combo, options);
+  }
+
+  size_t GetComboCount(QWidget *combo)
+  {
+    return InvokeRetFunction<size_t>(&IMiniQtHelper::GetComboCount, combo);
+  }
+
+  void SelectComboOption(QWidget *combo, const rdcstr &option)
+  {
+    InvokeVoidFunction(&IMiniQtHelper::SelectComboOption, combo, option);
+  }
+
+  QWidget *CreateProgressBar(bool horizontal)
+  {
+    return InvokeRetFunction<QWidget *>(&IMiniQtHelper::CreateProgressBar, horizontal);
+  }
+
+  void ResetProgressBar(QWidget *pbar)
+  {
+    InvokeVoidFunction(&IMiniQtHelper::ResetProgressBar, pbar);
+  }
+
+  void SetProgressBarValue(QWidget *pbar, int32_t value)
+  {
+    InvokeVoidFunction(&IMiniQtHelper::SetProgressBarValue, pbar, value);
+  }
+
+  void UpdateProgressBarValue(QWidget *pbar, int32_t delta)
+  {
+    InvokeVoidFunction(&IMiniQtHelper::UpdateProgressBarValue, pbar, delta);
+  }
+
+  int32_t GetProgressBarValue(QWidget *pbar)
+  {
+    return InvokeRetFunction<int>(&IMiniQtHelper::GetProgressBarValue, pbar);
+  }
+
+  void SetProgressBarRange(QWidget *pbar, int32_t minimum, int32_t maximum)
+  {
+    InvokeVoidFunction(&IMiniQtHelper::SetProgressBarRange, pbar, minimum, maximum);
+  }
+
+  int32_t GetProgressBarMinimum(QWidget *pbar)
+  {
+    return InvokeRetFunction<int>(&IMiniQtHelper::GetProgressBarMinimum, pbar);
+  }
+
+  int32_t GetProgressBarMaximum(QWidget *pbar)
+  {
+    return InvokeRetFunction<int>(&IMiniQtHelper::GetProgressBarMaximum, pbar);
+  }
+};
+
+struct ExtensionInvoker : UIThreadInvoker<IExtensionManager>
+{
+  MiniQtInvoker *m_MiniQt;
+  ExtensionInvoker(PythonShell *shell, IExtensionManager &obj) : UIThreadInvoker(shell, obj)
+  {
+    m_MiniQt = new MiniQtInvoker(shell, obj.GetMiniQtHelper());
+  }
+  virtual ~ExtensionInvoker() { delete m_MiniQt; }
+  //
+  ///////////////////////////////////////////////////////////////////////
+  // pass-through functions that don't need the UI thread
+  ///////////////////////////////////////////////////////////////////////
+  //
+  rdcarray<ExtensionMetadata> GetInstalledExtensions() { return m_Obj.GetInstalledExtensions(); }
+  rdcarray<rdcstr> GetLoadedExtensions() { return m_Obj.GetLoadedExtensions(); }
+  bool IsExtensionLoaded(rdcstr name) { return m_Obj.IsExtensionLoaded(name); }
+  rdcstr LoadExtension(rdcstr name) { return m_Obj.LoadExtension(name); }
+  bool IsPythonDebuggerConnected() { return m_Obj.IsPythonDebuggerConnected(); }
+  IMiniQtHelper &GetMiniQtHelper() { return *m_MiniQt; }
+  //
+  ///////////////////////////////////////////////////////////////////////
+  // functions that invoke onto the UI thread
+  ///////////////////////////////////////////////////////////////////////
+  //
+  void RegisterWindowMenu(WindowMenu base, const rdcarray<rdcstr> &submenus,
+                          ExtensionCallback callback)
+  {
+    InvokeVoidFunction(&IExtensionManager::RegisterWindowMenu, base, submenus, callback);
+  }
+
+  void RegisterPanelMenu(PanelMenu base, const rdcarray<rdcstr> &submenus, ExtensionCallback callback)
+  {
+    InvokeVoidFunction(&IExtensionManager::RegisterPanelMenu, base, submenus, callback);
+  }
+
+  void RegisterContextMenu(ContextMenu base, const rdcarray<rdcstr> &submenus,
+                           ExtensionCallback callback)
+  {
+    InvokeVoidFunction(&IExtensionManager::RegisterContextMenu, base, submenus, callback);
+  }
+
+  void MessageDialog(const rdcstr &text, const rdcstr &title)
+  {
+    InvokeVoidFunction(&IExtensionManager::MessageDialog, text, title);
+  }
+
+  void ErrorDialog(const rdcstr &text, const rdcstr &title)
+  {
+    InvokeVoidFunction(&IExtensionManager::ErrorDialog, text, title);
+  }
+
+  DialogButton QuestionDialog(const rdcstr &text, const rdcarray<DialogButton> &options,
+                              const rdcstr &title)
+  {
+    return InvokeRetFunction<DialogButton>(&IExtensionManager::QuestionDialog, text, options, title);
+  }
+
+  rdcstr OpenFileName(const rdcstr &caption, const rdcstr &dir, const rdcstr &filter)
+  {
+    return InvokeRetFunction<rdcstr>(&IExtensionManager::OpenFileName, caption, dir, filter);
+  }
+
+  rdcstr OpenDirectoryName(const rdcstr &caption, const rdcstr &dir)
+  {
+    return InvokeRetFunction<rdcstr>(&IExtensionManager::OpenDirectoryName, caption, dir);
+  }
+
+  rdcstr SaveFileName(const rdcstr &caption, const rdcstr &dir, const rdcstr &filter)
+  {
+    return InvokeRetFunction<rdcstr>(&IExtensionManager::SaveFileName, caption, dir, filter);
+  }
+
+  void MenuDisplaying(ContextMenu contextMenu, QMenu *menu, const ExtensionCallbackData &data)
+  {
+    InvokeVoidFunction(
+        (void(IExtensionManager::*)(ContextMenu, QMenu *, const ExtensionCallbackData &)) &
+            IExtensionManager::MenuDisplaying,
+        contextMenu, menu, data);
+  }
+  void MenuDisplaying(PanelMenu panelMenu, QMenu *menu, QWidget *extensionButton,
+                      const ExtensionCallbackData &data)
+  {
+    InvokeVoidFunction(
+        (void(IExtensionManager::*)(PanelMenu, QMenu *, QWidget *, const ExtensionCallbackData &)) &
+            IExtensionManager::MenuDisplaying,
+        panelMenu, menu, extensionButton, data);
+  }
+};
+
+struct ReplayControllerInvoker : IReplayController
+{
+  ReplayControllerInvoker(PythonShell *shell, ICaptureContext &ctx) : m_Shell(shell), m_Ctx(ctx) {}
+  virtual ~ReplayControllerInvoker() {}
+  PythonShell *m_Shell;
+  ICaptureContext &m_Ctx;
+
+  template <typename F, typename... paramTypes>
+  void InvokeVoidFunction(F ptr, paramTypes... params)
+  {
+    PythonContext *scriptContext = m_Shell->GetScriptContext();
+    if(scriptContext)
+      scriptContext->PausePythonThreading();
+    m_Ctx.Replay().BlockInvoke(
+        [this, ptr, params...](IReplayController *replay) { (replay->*ptr)(params...); });
+    if(scriptContext)
+      scriptContext->ResumePythonThreading();
+  }
+
+  template <typename R, typename F, typename... paramTypes>
+  R InvokeRetFunction(F ptr, paramTypes... params)
+  {
+    R ret = R();
+    PythonContext *scriptContext = m_Shell->GetScriptContext();
+    if(scriptContext)
+      scriptContext->PausePythonThreading();
+    m_Ctx.Replay().BlockInvoke([this, &ret, ptr, params...](IReplayController *replay) {
+      ret = (replay->*ptr)(params...);
+    });
+    if(scriptContext)
+      scriptContext->ResumePythonThreading();
+    return ret;
+  }
+
+  template <typename R, typename F, typename... paramTypes>
+  R &InvokeRetRefFunction(F ptr, paramTypes... params)
+  {
+    R *ret = NULL;
+    PythonContext *scriptContext = m_Shell->GetScriptContext();
+    if(scriptContext)
+      scriptContext->PausePythonThreading();
+    m_Ctx.Replay().BlockInvoke([this, &ret, ptr, params...](IReplayController *replay) {
+      ret = &(replay->*ptr)(params...);
+    });
+    if(scriptContext)
+      scriptContext->ResumePythonThreading();
+    return *ret;
+  }
+
+  APIProperties GetAPIProperties()
+  {
+    return InvokeRetFunction<APIProperties>(&IReplayController::GetAPIProperties);
+  }
+
+  rdcarray<WindowingSystem> GetSupportedWindowSystems()
+  {
+    return InvokeRetFunction<rdcarray<WindowingSystem>>(&IReplayController::GetSupportedWindowSystems);
+  }
+
+  IReplayOutput *CreateOutput(WindowingData window, ReplayOutputType type)
+  {
+    return InvokeRetFunction<IReplayOutput *>(&IReplayController::CreateOutput, window, type);
+  }
+
+  void Shutdown() {}
+
+  void ReplayLoop(WindowingData window, ResourceId texid) {}
+
+  rdcstr CreateRGPProfile(WindowingData window)
+  {
+    return InvokeRetFunction<rdcstr>(&IReplayController::CreateRGPProfile, window);
+  }
+
+  void CancelReplayLoop() {}
+
+  void FileChanged() {}
+
+  void SetFrameEvent(uint32_t eventId, bool force) {}
+
+  const D3D11Pipe::State *GetD3D11PipelineState()
+  {
+    return InvokeRetFunction<const D3D11Pipe::State *>(&IReplayController::GetD3D11PipelineState);
+  }
+
+  const D3D12Pipe::State *GetD3D12PipelineState()
+  {
+    return InvokeRetFunction<const D3D12Pipe::State *>(&IReplayController::GetD3D12PipelineState);
+  }
+
+  const GLPipe::State *GetGLPipelineState()
+  {
+    return InvokeRetFunction<const GLPipe::State *>(&IReplayController::GetGLPipelineState);
+  }
+
+  const VKPipe::State *GetVulkanPipelineState()
+  {
+    return InvokeRetFunction<const VKPipe::State *>(&IReplayController::GetVulkanPipelineState);
+  }
+
+  const PipeState &GetPipelineState()
+  {
+    return InvokeRetRefFunction<const PipeState>(&IReplayController::GetPipelineState);
+  }
+
+  rdcarray<Descriptor> GetDescriptors(ResourceId descriptorStore,
+                                      const rdcarray<DescriptorRange> &ranges)
+  {
+    return InvokeRetFunction<rdcarray<Descriptor>>(&IReplayController::GetDescriptors,
+                                                   descriptorStore, ranges);
+  }
+
+  rdcarray<SamplerDescriptor> GetSamplerDescriptors(ResourceId descriptorStore,
+                                                    const rdcarray<DescriptorRange> &ranges)
+  {
+    return InvokeRetFunction<rdcarray<SamplerDescriptor>>(&IReplayController::GetSamplerDescriptors,
+                                                          descriptorStore, ranges);
+  }
+
+  const rdcarray<DescriptorAccess> &GetDescriptorAccess()
+  {
+    return InvokeRetRefFunction<const rdcarray<DescriptorAccess>>(
+        &IReplayController::GetDescriptorAccess);
+  }
+
+  rdcarray<DescriptorLogicalLocation> GetDescriptorLocations(ResourceId descriptorStore,
+                                                             const rdcarray<DescriptorRange> &ranges)
+  {
+    return InvokeRetFunction<rdcarray<DescriptorLogicalLocation>>(
+        &IReplayController::GetDescriptorLocations, descriptorStore, ranges);
+  }
+
+  rdcarray<rdcstr> GetDisassemblyTargets(bool withPipeline)
+  {
+    return InvokeRetFunction<rdcarray<rdcstr>>(&IReplayController::GetDisassemblyTargets,
+                                               withPipeline);
+  }
+
+  rdcstr DisassembleShader(ResourceId pipeline, const ShaderReflection *refl, const rdcstr &target)
+  {
+    return InvokeRetFunction<rdcstr>(&IReplayController::DisassembleShader, pipeline, refl, target);
+  }
+
+  void SetCustomShaderIncludes(const rdcarray<rdcstr> &directories) {}
+
+  rdcpair<ResourceId, rdcstr> BuildCustomShader(const rdcstr &entry, ShaderEncoding sourceEncoding,
+                                                bytebuf source,
+                                                const ShaderCompileFlags &compileFlags,
+                                                ShaderStage type)
+  {
+    return InvokeRetFunction<rdcpair<ResourceId, rdcstr>>(
+        &IReplayController::BuildCustomShader, entry, sourceEncoding, source, compileFlags, type);
+  }
+
+  void FreeCustomShader(ResourceId id) {}
+
+  rdcpair<ResourceId, rdcstr> BuildTargetShader(const rdcstr &entry, ShaderEncoding sourceEncoding,
+                                                bytebuf source,
+                                                const ShaderCompileFlags &compileFlags,
+                                                ShaderStage type)
+  {
+    return InvokeRetFunction<rdcpair<ResourceId, rdcstr>>(
+        &IReplayController::BuildTargetShader, entry, sourceEncoding, source, compileFlags, type);
+  }
+
+  rdcarray<ShaderEncoding> GetTargetShaderEncodings()
+  {
+    return InvokeRetFunction<rdcarray<ShaderEncoding>>(&IReplayController::GetTargetShaderEncodings);
+  }
+
+  rdcarray<ShaderEncoding> GetCustomShaderEncodings()
+  {
+    return InvokeRetFunction<rdcarray<ShaderEncoding>>(&IReplayController::GetCustomShaderEncodings);
+  }
+
+  rdcarray<ShaderSourcePrefix> GetCustomShaderSourcePrefixes()
+  {
+    return InvokeRetFunction<rdcarray<ShaderSourcePrefix>>(
+        &IReplayController::GetCustomShaderSourcePrefixes);
+  }
+
+  void ReplaceResource(ResourceId original, ResourceId replacement) {}
+
+  void ClearReplayCache() {}
+
+  void ReloadShaderDebugInformation() {}
+
+  void RemoveReplacement(ResourceId id) {}
+
+  void FreeTargetResource(ResourceId id) {}
+
+  FrameDescription GetFrameInfo()
+  {
+    return InvokeRetFunction<FrameDescription>(&IReplayController::GetFrameInfo);
+  }
+
+  const SDFile &GetStructuredFile()
+  {
+    return InvokeRetRefFunction<const SDFile>(&IReplayController::GetStructuredFile);
+  }
+
+  void AddFakeMarkers() {}
+
+  const rdcarray<ActionDescription> &GetRootActions()
+  {
+    return InvokeRetRefFunction<const rdcarray<ActionDescription>>(&IReplayController::GetRootActions);
+  }
+
+  rdcarray<CounterResult> FetchCounters(const rdcarray<GPUCounter> &counters)
+  {
+    return InvokeRetFunction<rdcarray<CounterResult>>(&IReplayController::FetchCounters, counters);
+  }
+
+  rdcarray<GPUCounter> EnumerateCounters()
+  {
+    return InvokeRetFunction<rdcarray<GPUCounter>>(&IReplayController::EnumerateCounters);
+  }
+
+  CounterDescription DescribeCounter(GPUCounter counter)
+  {
+    return InvokeRetFunction<CounterDescription>(&IReplayController::DescribeCounter, counter);
+  }
+
+  const rdcarray<ResourceDescription> &GetResources()
+  {
+    return InvokeRetRefFunction<const rdcarray<ResourceDescription>>(&IReplayController::GetResources);
+  }
+
+  const rdcarray<TextureDescription> &GetTextures()
+  {
+    return InvokeRetRefFunction<const rdcarray<TextureDescription>>(&IReplayController::GetTextures);
+  }
+
+  const rdcarray<BufferDescription> &GetBuffers()
+  {
+    return InvokeRetRefFunction<const rdcarray<BufferDescription>>(&IReplayController::GetBuffers);
+  }
+
+  const rdcarray<DescriptorStoreDescription> &GetDescriptorStores()
+  {
+    return InvokeRetRefFunction<const rdcarray<DescriptorStoreDescription>>(
+        &IReplayController::GetDescriptorStores);
+  }
+
+  rdcarray<DebugMessage> GetDebugMessages()
+  {
+    return InvokeRetFunction<rdcarray<DebugMessage>>(&IReplayController::GetDebugMessages);
+  }
+
+  ResultDetails GetFatalErrorStatus()
+  {
+    return InvokeRetFunction<ResultDetails>(&IReplayController::GetFatalErrorStatus);
+  }
+
+  rdcarray<ShaderEntryPoint> GetShaderEntryPoints(ResourceId shader)
+  {
+    return InvokeRetFunction<rdcarray<ShaderEntryPoint>>(&IReplayController::GetShaderEntryPoints,
+                                                         shader);
+  }
+
+  const ShaderReflection *GetShader(ResourceId pipeline, ResourceId shader, ShaderEntryPoint entry)
+  {
+    return InvokeRetFunction<const ShaderReflection *>(&IReplayController::GetShader, pipeline,
+                                                       shader, entry);
+  }
+
+  PixelValue PickPixel(ResourceId textureId, uint32_t x, uint32_t y, const Subresource &sub,
+                       CompType typeCast)
+  {
+    return InvokeRetFunction<PixelValue>(&IReplayController::PickPixel, textureId, x, y, sub,
+                                         typeCast);
+  }
+
+  rdcpair<PixelValue, PixelValue> GetMinMax(ResourceId textureId, const Subresource &sub,
+                                            CompType typeCast)
+  {
+    return InvokeRetFunction<rdcpair<PixelValue, PixelValue>>(&IReplayController::GetMinMax,
+                                                              textureId, sub, typeCast);
+  }
+
+  rdcarray<uint32_t> GetHistogram(ResourceId textureId, const Subresource &sub, CompType typeCast,
+                                  float minval, float maxval, const rdcfixedarray<bool, 4> &channels)
+  {
+    return InvokeRetFunction<rdcarray<uint32_t>>(&IReplayController::GetHistogram, textureId, sub,
+                                                 typeCast, minval, maxval, channels);
+  }
+
+  rdcarray<PixelModification> PixelHistory(ResourceId texture, uint32_t x, uint32_t y,
+                                           const Subresource &sub, CompType typeCast)
+  {
+    return InvokeRetFunction<rdcarray<PixelModification>>(&IReplayController::PixelHistory, texture,
+                                                          x, y, sub, typeCast);
+  }
+
+  ShaderDebugTrace *DebugVertex(uint32_t vertid, uint32_t instid, uint32_t idx, uint32_t view)
+  {
+    return InvokeRetFunction<ShaderDebugTrace *>(&IReplayController::DebugVertex, vertid, instid,
+                                                 idx, view);
+  }
+
+  ShaderDebugTrace *DebugPixel(uint32_t x, uint32_t y, const DebugPixelInputs &inputs)
+  {
+    return InvokeRetFunction<ShaderDebugTrace *>(&IReplayController::DebugPixel, x, y, inputs);
+  }
+
+  ShaderDebugTrace *DebugThread(const rdcfixedarray<uint32_t, 3> &groupid,
+                                const rdcfixedarray<uint32_t, 3> &threadid)
+  {
+    return InvokeRetFunction<ShaderDebugTrace *>(&IReplayController::DebugThread, groupid, threadid);
+  }
+
+  ShaderDebugTrace *DebugMeshThread(const rdcfixedarray<uint32_t, 3> &groupid,
+                                    const rdcfixedarray<uint32_t, 3> &threadid)
+  {
+    return InvokeRetFunction<ShaderDebugTrace *>(&IReplayController::DebugMeshThread, groupid,
+                                                 threadid);
+  }
+
+  rdcarray<ShaderDebugState> ContinueDebug(ShaderDebugger *debugger)
+  {
+    return InvokeRetFunction<rdcarray<ShaderDebugState>>(&IReplayController::ContinueDebug, debugger);
+  }
+
+  void FreeTrace(ShaderDebugTrace *trace)
+  {
+    return InvokeVoidFunction(&IReplayController::FreeTrace, trace);
+  }
+
+  rdcarray<EventUsage> GetUsage(ResourceId id)
+  {
+    return InvokeRetFunction<rdcarray<EventUsage>>(&IReplayController::GetUsage, id);
+  }
+
+  rdcarray<ShaderVariable> GetCBufferVariableContents(ResourceId pipeline, ResourceId shader,
+                                                      ShaderStage stage, const rdcstr &entryPoint,
+                                                      uint32_t cbufslot, ResourceId buffer,
+                                                      uint64_t offset, uint64_t length)
+  {
+    return InvokeRetFunction<rdcarray<ShaderVariable>>(
+        &IReplayController::GetCBufferVariableContents, pipeline, shader, stage, entryPoint,
+        cbufslot, buffer, offset, length);
+  }
+
+  ResultDetails SaveTexture(const TextureSave &saveData, const rdcstr &path)
+  {
+    return InvokeRetFunction<ResultDetails>(&IReplayController::SaveTexture, saveData, path);
+  }
+
+  MeshFormat GetPostVSData(uint32_t instance, uint32_t view, MeshDataStage stage)
+  {
+    return InvokeRetFunction<MeshFormat>(&IReplayController::GetPostVSData, instance, view, stage);
+  }
+
+  bytebuf GetBufferData(ResourceId buff, uint64_t offset, uint64_t len)
+  {
+    return InvokeRetFunction<bytebuf>(&IReplayController::GetBufferData, buff, offset, len);
+  }
+
+  bytebuf GetTextureData(ResourceId tex, const Subresource &sub)
+  {
+    return InvokeRetFunction<bytebuf>(&IReplayController::GetTextureData, tex, sub);
+  }
+};
+
+struct IMainWindowInvoker : UIThreadInvoker<IMainWindow>
+{
+  IMainWindowInvoker(PythonShell *shell, IMainWindow &obj) : UIThreadInvoker(shell, obj) {}
+  virtual ~IMainWindowInvoker() {}
+
+  QWidget *Widget() { return m_Obj.Widget(); }
+  void RegisterShortcut(const rdcstr &shortcut, QWidget *widget, ShortcutCallback callback)
+  {
+    return InvokeVoidFunction(&IMainWindow::RegisterShortcut, shortcut, widget, callback);
+  }
+  void UnregisterShortcut(const rdcstr &shortcut, QWidget *widget)
+  {
+    return InvokeVoidFunction(&IMainWindow::UnregisterShortcut, shortcut, widget);
+  }
+  void BringToFront() { return InvokeVoidFunction(&IMainWindow::BringToFront); }
+};
+
+struct IEventBrowserInvoker : UIThreadInvoker<IEventBrowser>
+{
+  IEventBrowserInvoker(PythonShell *shell, IEventBrowser &obj) : UIThreadInvoker(shell, obj) {}
+  virtual ~IEventBrowserInvoker() {}
+
+  QWidget *Widget() { return m_Obj.Widget(); }
+  void UpdateDurationColumn() { return InvokeVoidFunction(&IEventBrowser::UpdateDurationColumn); }
+  APIEvent GetAPIEventForEID(uint32_t eventId)
+  {
+    return InvokeRetFunction<APIEvent>(&IEventBrowser::GetAPIEventForEID, eventId);
+  }
+  const ActionDescription *GetActionForEID(uint32_t eventId)
+  {
+    return InvokeRetFunction<const ActionDescription *>(&IEventBrowser::GetActionForEID, eventId);
+  }
+  rdcstr GetEventName(uint32_t eventId)
+  {
+    return InvokeRetFunction<rdcstr>(&IEventBrowser::GetEventName, eventId);
+  }
+  bool IsAPIEventVisible(uint32_t eventId)
+  {
+    return InvokeRetFunction<bool>(&IEventBrowser::IsAPIEventVisible, eventId);
+  }
+  bool RegisterEventFilterFunction(const rdcstr &name, const rdcstr &description,
+                                   EventFilterCallback filter, FilterParseCallback parser,
+                                   AutoCompleteCallback completer)
+  {
+    return InvokeRetFunction<bool>(&IEventBrowser::RegisterEventFilterFunction, name, description,
+                                   filter, parser, completer);
+  }
+  bool UnregisterEventFilterFunction(const rdcstr &name)
+  {
+    return InvokeRetFunction<bool>(&IEventBrowser::UnregisterEventFilterFunction, name);
+  }
+  void SetCurrentFilterText(const rdcstr &text)
+  {
+    return InvokeVoidFunction(&IEventBrowser::SetCurrentFilterText, text);
+  };
+  rdcstr GetCurrentFilterText()
+  {
+    return InvokeRetFunction<rdcstr>(&IEventBrowser::GetCurrentFilterText);
+  }
+  void SetUseCustomActionNames(bool use)
+  {
+    return InvokeVoidFunction(&IEventBrowser::SetUseCustomActionNames, use);
+  }
+  void SetShowParameterNames(bool show)
+  {
+    return InvokeVoidFunction(&IEventBrowser::SetShowParameterNames, show);
+  }
+  void SetShowAllParameters(bool show)
+  {
+    return InvokeVoidFunction(&IEventBrowser::SetShowAllParameters, show);
+  }
+  void SetEmptyRegionsVisible(bool show)
+  {
+    return InvokeVoidFunction(&IEventBrowser::SetEmptyRegionsVisible, show);
+  }
+  void SetHighlightedAnnotation(const rdcstr &annotationPath)
+  {
+    return InvokeVoidFunction(&IEventBrowser::SetHighlightedAnnotation, annotationPath);
+  }
+  rdcstr GetHighlightedAnnotation()
+  {
+    return InvokeRetFunction<rdcstr>(&IEventBrowser::GetHighlightedAnnotation);
+  }
+  void SetDurationColumnVisible(bool show)
+  {
+    return InvokeVoidFunction(&IEventBrowser::SetDurationColumnVisible, show);
+  }
+  void SetAnnotationColumnVisible(bool show)
+  {
+    return InvokeVoidFunction(&IEventBrowser::SetAnnotationColumnVisible, show);
+  }
+};
+
+struct IAPIInspectorInvoker : UIThreadInvoker<IAPIInspector>
+{
+  IAPIInspectorInvoker(PythonShell *shell, IAPIInspector &obj) : UIThreadInvoker(shell, obj) {}
+  virtual ~IAPIInspectorInvoker() {}
+
+  QWidget *Widget() { return m_Obj.Widget(); }
+  virtual void Refresh() { return InvokeVoidFunction(&IAPIInspector::Refresh); }
+  virtual void RevealParameter(SDObject *param)
+  {
+    return InvokeVoidFunction(&IAPIInspector::RevealParameter, param);
+  }
+};
+
+struct IAnnotationViewerInvoker : UIThreadInvoker<IAnnotationViewer>
+{
+  IAnnotationViewerInvoker(PythonShell *shell, IAnnotationViewer &obj) : UIThreadInvoker(shell, obj)
+  {
+  }
+  virtual ~IAnnotationViewerInvoker() {}
+
+  QWidget *Widget() { return m_Obj.Widget(); }
+
+  void RevealAnnotation(const rdcstr &keyPath)
+  {
+    return InvokeVoidFunction(&IAnnotationViewer::RevealAnnotation, keyPath);
+  }
+};
+
+struct ITextureViewerInvoker : UIThreadInvoker<ITextureViewer>
+{
+  ITextureViewerInvoker(PythonShell *shell, ITextureViewer &obj) : UIThreadInvoker(shell, obj) {}
+  virtual ~ITextureViewerInvoker() {}
+
+  QWidget *Widget() { return m_Obj.Widget(); }
+  void ViewTexture(ResourceId resourceId, CompType typeCast, bool focus)
+  {
+    return InvokeVoidFunction(&ITextureViewer::ViewTexture, resourceId, typeCast, focus);
+  }
+  void ViewFollowedResource(FollowType followType, ShaderStage stage, int32_t index,
+                            int32_t arrayElement)
+  {
+    return InvokeVoidFunction(&ITextureViewer::ViewFollowedResource, followType, stage, index,
+                              arrayElement);
+  }
+  ResourceId GetCurrentResource()
+  {
+    return InvokeRetFunction<ResourceId>(&ITextureViewer::GetCurrentResource);
+  }
+  Subresource GetSelectedSubresource()
+  {
+    return InvokeRetFunction<Subresource>(&ITextureViewer::GetSelectedSubresource);
+  }
+  void SetSelectedSubresource(Subresource sub)
+  {
+    return InvokeVoidFunction(&ITextureViewer::SetSelectedSubresource, sub);
+  }
+  void GotoLocation(uint32_t x, uint32_t y)
+  {
+    return InvokeVoidFunction(&ITextureViewer::GotoLocation, x, y);
+  }
+  rdcpair<int32_t, int32_t> GetPickedLocation()
+  {
+    return InvokeRetFunction<rdcpair<int32_t, int32_t>>(&ITextureViewer::GetPickedLocation);
+  }
+  DebugOverlay GetTextureOverlay()
+  {
+    return InvokeRetFunction<DebugOverlay>(&ITextureViewer::GetTextureOverlay);
+  }
+  void SetTextureOverlay(DebugOverlay overlay)
+  {
+    return InvokeVoidFunction(&ITextureViewer::SetTextureOverlay, overlay);
+  }
+  bool IsZoomAutoFit() { return InvokeRetFunction<bool>(&ITextureViewer::IsZoomAutoFit); }
+  float GetZoomLevel() { return InvokeRetFunction<float>(&ITextureViewer::GetZoomLevel); }
+  void SetZoomLevel(bool autofit, float zoom)
+  {
+    return InvokeVoidFunction(&ITextureViewer::SetZoomLevel, autofit, zoom);
+  }
+  rdcpair<float, float> GetHistogramRange()
+  {
+    return InvokeRetFunction<rdcpair<float, float>>(&ITextureViewer::GetHistogramRange);
+  }
+  void SetHistogramRange(float blackpoint, float whitepoint)
+  {
+    return InvokeVoidFunction(&ITextureViewer::SetHistogramRange, blackpoint, whitepoint);
+  }
+  uint32_t GetChannelVisibilityBits()
+  {
+    return InvokeRetFunction<uint32_t>(&ITextureViewer::GetChannelVisibilityBits);
+  }
+  void SetChannelVisibility(bool red, bool green, bool blue, bool alpha)
+  {
+    return InvokeVoidFunction(&ITextureViewer::SetChannelVisibility, red, green, blue, alpha);
+  }
+};
+
+struct IBufferViewerInvoker : UIThreadInvoker<IBufferViewer>
+{
+  IBufferViewerInvoker(PythonShell *shell, IBufferViewer &obj) : UIThreadInvoker(shell, obj) {}
+  virtual ~IBufferViewerInvoker() {}
+
+  QWidget *Widget() { return m_Obj.Widget(); }
+  void ScrollToRow(int32_t row, MeshDataStage stage)
+  {
+    return InvokeVoidFunction(&IBufferViewer::ScrollToRow, row, stage);
+  }
+  void ScrollToColumn(int32_t column, MeshDataStage stage)
+  {
+    return InvokeVoidFunction(&IBufferViewer::ScrollToColumn, column, stage);
+  }
+  void ShowMeshData(MeshDataStage stage)
+  {
+    return InvokeVoidFunction(&IBufferViewer::ShowMeshData, stage);
+  }
+  void SetCurrentInstance(int32_t instance)
+  {
+    return InvokeVoidFunction(&IBufferViewer::SetCurrentInstance, instance);
+  }
+  void SetCurrentView(int32_t view)
+  {
+    return InvokeVoidFunction(&IBufferViewer::SetCurrentView, view);
+  }
+  void SetPreviewStage(MeshDataStage stage)
+  {
+    return InvokeVoidFunction(&IBufferViewer::SetPreviewStage, stage);
+  }
+};
+
+struct IPipelineStateViewerInvoker : UIThreadInvoker<IPipelineStateViewer>
+{
+  IPipelineStateViewerInvoker(PythonShell *shell, IPipelineStateViewer &obj)
+      : UIThreadInvoker(shell, obj)
+  {
+  }
+  virtual ~IPipelineStateViewerInvoker() {}
+
+  QWidget *Widget() { return m_Obj.Widget(); }
+  virtual bool SaveShaderFile(const ShaderReflection *shader)
+  {
+    return InvokeRetFunction<bool>(&IPipelineStateViewer::SaveShaderFile, shader);
+  }
+  virtual void SelectPipelineStage(PipelineStage stage)
+  {
+    return InvokeVoidFunction(&IPipelineStateViewer::SelectPipelineStage, stage);
+  }
+};
+
+struct ICaptureConnectionInvoker : UIThreadInvoker<ICaptureConnection>
+{
+  ICaptureConnectionInvoker(PythonShell *shell, ICaptureConnection &obj)
+      : UIThreadInvoker(shell, obj)
+  {
+    // delete ourself when the connection dies
+    obj.RegisterClosedCallback([this](ICaptureConnection *) { delete this; });
+  }
+  virtual ~ICaptureConnectionInvoker() {}
+
+  QWidget *Widget() { return m_Obj.Widget(); }
+  void RegisterClosedCallback(ClosedCallback method)
+  {
+    return InvokeVoidFunction(&ICaptureConnection::RegisterClosedCallback, method);
+  }
+  bool IsConnected() { return InvokeRetFunction<bool>(&ICaptureConnection::IsConnected); }
+  void PreventAutoClose() { return InvokeVoidFunction(&ICaptureConnection::PreventAutoClose); }
+  rdcarray<rdcstr> GetAPIs()
+  {
+    return InvokeRetFunction<rdcarray<rdcstr>>(&ICaptureConnection::GetAPIs);
+  }
+  void QueueCapture(int frameNumber, int numFrames)
+  {
+    return InvokeVoidFunction(&ICaptureConnection::QueueCapture, frameNumber, numFrames);
+  }
+  void TimedCapture(float secondsDelay, int numFrames)
+  {
+    return InvokeVoidFunction(&ICaptureConnection::TimedCapture, secondsDelay, numFrames);
+  }
+  void CycleActiveWindow() { return InvokeVoidFunction(&ICaptureConnection::CycleActiveWindow); }
+  rdcstr Target() { return InvokeRetFunction<rdcstr>(&ICaptureConnection::Target); }
+  rdcstr Hostname() { return InvokeRetFunction<rdcstr>(&ICaptureConnection::Hostname); }
+  rdcstr FriendlyHostname()
+  {
+    return InvokeRetFunction<rdcstr>(&ICaptureConnection::FriendlyHostname);
+  }
+  void Close(bool discardUnsaved)
+  {
+    return InvokeVoidFunction(&ICaptureConnection::Close, discardUnsaved);
+  }
+  rdcarray<ConnectedTempCapture> GetCaptures()
+  {
+    return InvokeRetFunction<rdcarray<ConnectedTempCapture>>(&ICaptureConnection::GetCaptures);
+  }
+  void OpenCapture(uint32_t ID) { return InvokeVoidFunction(&ICaptureConnection::OpenCapture, ID); }
+  void DeleteCapture(uint32_t ID, bool promptForSave)
+  {
+    return InvokeVoidFunction(&ICaptureConnection::DeleteCapture, ID, promptForSave);
+  }
+  void SaveCapture(uint32_t ID, rdcstr filename)
+  {
+    return InvokeVoidFunction(&ICaptureConnection::SaveCapture, ID, filename);
+  }
+  rdcarray<uint32_t> GetChildProcesses()
+  {
+    return InvokeRetFunction<rdcarray<uint32_t>>(&ICaptureConnection::GetChildProcesses);
+  }
+  ICaptureConnection *ConnectToChild(uint32_t pid)
+  {
+    ICaptureConnection *ret =
+        InvokeRetFunction<ICaptureConnection *>(&ICaptureConnection::ConnectToChild, pid);
+
+    if(!ret)
+      return ret;
+
+    return new ICaptureConnectionInvoker(m_Shell, *ret);
+  }
+};
+
+struct ICaptureDialogInvoker : UIThreadInvoker<ICaptureDialog>
+{
+  ICaptureDialogInvoker(PythonShell *shell, ICaptureDialog &obj) : UIThreadInvoker(shell, obj) {}
+  virtual ~ICaptureDialogInvoker() {}
+
+  QWidget *Widget() { return m_Obj.Widget(); }
+  bool IsInjectMode() { return InvokeRetFunction<bool>(&ICaptureDialog::IsInjectMode); }
+  void SetInjectMode(bool inject)
+  {
+    return InvokeVoidFunction(&ICaptureDialog::SetInjectMode, inject);
+  }
+  void SetExecutableFilename(const rdcstr &filename)
+  {
+    return InvokeVoidFunction(&ICaptureDialog::SetExecutableFilename, filename);
+  }
+  void SetWorkingDirectory(const rdcstr &dir)
+  {
+    return InvokeVoidFunction(&ICaptureDialog::SetWorkingDirectory, dir);
+  }
+  void SetCommandLine(const rdcstr &cmd)
+  {
+    return InvokeVoidFunction(&ICaptureDialog::SetCommandLine, cmd);
+  }
+  void SetEnvironmentModifications(const rdcarray<EnvironmentModification> &modifications)
+  {
+    return InvokeVoidFunction(&ICaptureDialog::SetEnvironmentModifications, modifications);
+  }
+  void SetSettings(CaptureSettings settings)
+  {
+    return InvokeVoidFunction(&ICaptureDialog::SetSettings, settings);
+  }
+  CaptureSettings Settings()
+  {
+    return InvokeRetFunction<CaptureSettings>(&ICaptureDialog::Settings);
+  }
+  ICaptureConnection *Launch()
+  {
+    ICaptureConnection *ret = InvokeRetFunction<ICaptureConnection *>(&ICaptureDialog::Launch);
+
+    if(!ret)
+      return ret;
+
+    return new ICaptureConnectionInvoker(m_Shell, *ret);
+  }
+  void LoadSettings(const rdcstr &filename)
+  {
+    return InvokeVoidFunction(&ICaptureDialog::LoadSettings, filename);
+  }
+  void SaveSettings(const rdcstr &filename)
+  {
+    return InvokeVoidFunction(&ICaptureDialog::SaveSettings, filename);
+  }
+  void UpdateGlobalHook() { return InvokeVoidFunction(&ICaptureDialog::UpdateGlobalHook); }
+  void UpdateRemoteHost() { return InvokeVoidFunction(&ICaptureDialog::UpdateRemoteHost); }
+};
+
+struct IDebugMessageViewInvoker : UIThreadInvoker<IDebugMessageView>
+{
+  IDebugMessageViewInvoker(PythonShell *shell, IDebugMessageView &obj) : UIThreadInvoker(shell, obj)
+  {
+  }
+  virtual ~IDebugMessageViewInvoker() {}
+
+  QWidget *Widget() { return m_Obj.Widget(); }
+};
+
+struct IDiagnosticLogViewInvoker : UIThreadInvoker<IDiagnosticLogView>
+{
+  IDiagnosticLogViewInvoker(PythonShell *shell, IDiagnosticLogView &obj)
+      : UIThreadInvoker(shell, obj)
+  {
+  }
+  virtual ~IDiagnosticLogViewInvoker() {}
+
+  QWidget *Widget() { return m_Obj.Widget(); }
+};
+
+struct ICommentViewInvoker : UIThreadInvoker<ICommentView>
+{
+  ICommentViewInvoker(PythonShell *shell, ICommentView &obj) : UIThreadInvoker(shell, obj) {}
+  virtual ~ICommentViewInvoker() {}
+
+  QWidget *Widget() { return m_Obj.Widget(); }
+  virtual void SetComments(const rdcstr &text)
+  {
+    return InvokeVoidFunction(&ICommentView::SetComments, text);
+  }
+  virtual rdcstr GetComments() { return InvokeRetFunction<rdcstr>(&ICommentView::GetComments); }
+};
+
+struct IPerformanceCounterViewerInvoker : UIThreadInvoker<IPerformanceCounterViewer>
+{
+  IPerformanceCounterViewerInvoker(PythonShell *shell, IPerformanceCounterViewer &obj)
+      : UIThreadInvoker(shell, obj)
+  {
+  }
+  virtual ~IPerformanceCounterViewerInvoker() {}
+
+  QWidget *Widget() { return m_Obj.Widget(); }
+  void UpdateDurationColumn()
+  {
+    return InvokeVoidFunction(&IPerformanceCounterViewer::UpdateDurationColumn);
+  }
+};
+
+struct IStatisticsViewerInvoker : UIThreadInvoker<IStatisticsViewer>
+{
+  IStatisticsViewerInvoker(PythonShell *shell, IStatisticsViewer &obj) : UIThreadInvoker(shell, obj)
+  {
+  }
+  virtual ~IStatisticsViewerInvoker() {}
+
+  QWidget *Widget() { return m_Obj.Widget(); }
+};
+
+struct ITimelineBarInvoker : UIThreadInvoker<ITimelineBar>
+{
+  ITimelineBarInvoker(PythonShell *shell, ITimelineBar &obj) : UIThreadInvoker(shell, obj) {}
+  virtual ~ITimelineBarInvoker() {}
+
+  QWidget *Widget() { return m_Obj.Widget(); }
+  void HighlightResourceUsage(ResourceId id)
+  {
+    return InvokeVoidFunction(&ITimelineBar::HighlightResourceUsage, id);
+  }
+  void HighlightHistory(ResourceId id, const rdcarray<PixelModification> &history)
+  {
+    return InvokeVoidFunction(&ITimelineBar::HighlightHistory, id, history);
+  }
+};
+
+struct IPythonShellInvoker : UIThreadInvoker<IPythonShell>
+{
+  IPythonShellInvoker(PythonShell *shell, IPythonShell &obj) : UIThreadInvoker(shell, obj) {}
+  virtual ~IPythonShellInvoker() {}
+
+  QWidget *Widget() { return m_Obj.Widget(); }
+  bool CheckUnsavedChanges() { return InvokeRetFunction<bool>(&IPythonShell::CheckUnsavedChanges); }
+  bool LoadScriptFromFilename(rdcstr filename)
+  {
+    return InvokeRetFunction<bool>(&IPythonShell::LoadScriptFromFilename, filename);
+  }
+  void CreateNewScriptEditor(rdcstr name, rdcstr text)
+  {
+    return InvokeVoidFunction(&IPythonShell::CreateNewScriptEditor, name, text);
+  }
+  rdcstr GetScriptText() { return InvokeRetFunction<rdcstr>(&IPythonShell::GetScriptText); }
+  void RunScript() { return InvokeVoidFunction(&IPythonShell::RunScript); }
+  void DebugScript() { return InvokeVoidFunction(&IPythonShell::DebugScript); }
+  void SetExtensionOutputFilter(const rdcstr &extensionName)
+  {
+    return InvokeVoidFunction(&IPythonShell::SetExtensionOutputFilter, extensionName);
+  }
+  void SetScriptOutputFilter() { return InvokeVoidFunction(&IPythonShell::SetScriptOutputFilter); }
+  void RemoveOutputFilter() { return InvokeVoidFunction(&IPythonShell::RemoveOutputFilter); }
+  void ShowOutput() { return InvokeVoidFunction(&IPythonShell::ShowOutput); }
+  void ShowREPL() { return InvokeVoidFunction(&IPythonShell::ShowREPL); }
+  void ShowHelp() { return InvokeVoidFunction(&IPythonShell::ShowHelp); }
+};
+
+struct IResourceInspectorInvoker : UIThreadInvoker<IResourceInspector>
+{
+  IResourceInspectorInvoker(PythonShell *shell, IResourceInspector &obj)
+      : UIThreadInvoker(shell, obj)
+  {
+  }
+  virtual ~IResourceInspectorInvoker() {}
+
+  QWidget *Widget() { return m_Obj.Widget(); }
+  void Inspect(ResourceId id) { return InvokeVoidFunction(&IResourceInspector::Inspect, id); }
+  ResourceId CurrentResource()
+  {
+    return InvokeRetFunction<ResourceId>(&IResourceInspector::CurrentResource);
+  }
+  void RevealParameter(SDObject *param)
+  {
+    return InvokeVoidFunction(&IResourceInspector::RevealParameter, param);
+  }
+};
+
+struct CaptureContextInvoker : UIThreadInvoker<ICaptureContext>
+{
+  ExtensionInvoker *m_Ext;
+  ReplayControllerInvoker m_ReplayController;
+
+#define WINDOW_INVOKER(iface)                              \
+  iface##Invoker *m_invoker##iface = NULL;                 \
+  iface *WrapInvoker(iface *i)                             \
+  {                                                        \
+    if(!m_invoker##iface || &m_invoker##iface->m_Obj != i) \
+    {                                                      \
+      delete m_invoker##iface;                             \
+      m_invoker##iface = new iface##Invoker(m_Shell, *i);  \
+    }                                                      \
+    return m_invoker##iface;                               \
+  }
+
+  WINDOW_INVOKER(IMainWindow);
+  WINDOW_INVOKER(IEventBrowser);
+  WINDOW_INVOKER(IAPIInspector);
+  WINDOW_INVOKER(IAnnotationViewer);
+  WINDOW_INVOKER(ITextureViewer);
+  WINDOW_INVOKER(IBufferViewer);
+  WINDOW_INVOKER(IPipelineStateViewer);
+  WINDOW_INVOKER(ICaptureDialog);
+  WINDOW_INVOKER(IDebugMessageView);
+  WINDOW_INVOKER(IDiagnosticLogView);
+  WINDOW_INVOKER(ICommentView);
+  WINDOW_INVOKER(IPerformanceCounterViewer);
+  WINDOW_INVOKER(IStatisticsViewer);
+  WINDOW_INVOKER(ITimelineBar);
+  WINDOW_INVOKER(IPythonShell);
+  WINDOW_INVOKER(IResourceInspector);
+
+  CaptureContextInvoker(PythonShell *shell, ICaptureContext &obj)
+      : UIThreadInvoker(shell, obj), m_ReplayController(shell, obj)
+  {
+    m_Ext = new ExtensionInvoker(shell, obj.Extensions());
+  }
+  virtual ~CaptureContextInvoker() { delete m_Ext; }
+  //
+  ///////////////////////////////////////////////////////////////////////
+  // pass-through functions that don't need the UI thread
+  ///////////////////////////////////////////////////////////////////////
+  //
+  virtual rdcstr TempCaptureFilename(const rdcstr &appname) override
+  {
+    return m_Obj.TempCaptureFilename(appname);
+  }
+  virtual IExtensionManager &Extensions() override { return *m_Ext; }
+  virtual IReplayManager &Replay() override { return m_Obj.Replay(); }
+  virtual bool IsCaptureLoaded() override { return m_Obj.IsCaptureLoaded(); }
+  virtual bool IsCaptureLocal() override { return m_Obj.IsCaptureLocal(); }
+  virtual bool IsCaptureTemporary() override { return m_Obj.IsCaptureTemporary(); }
+  virtual bool IsCaptureLoading() override { return m_Obj.IsCaptureLoading(); }
+  virtual ResultDetails GetFatalError() override { return m_Obj.GetFatalError(); }
+  virtual rdcstr GetCaptureFilename() override { return m_Obj.GetCaptureFilename(); }
+  virtual CaptureModifications GetCaptureModifications() override
+  {
+    return m_Obj.GetCaptureModifications();
+  }
+  virtual FrameDescription FrameInfo() override { return m_Obj.FrameInfo(); }
+  virtual APIProperties APIProps() override { return m_Obj.APIProps(); }
+  virtual rdcarray<ShaderEncoding> TargetShaderEncodings() override
+  {
+    return m_Obj.TargetShaderEncodings();
+  }
+  virtual rdcarray<ShaderEncoding> CustomShaderEncodings() override
+  {
+    return m_Obj.CustomShaderEncodings();
+  }
+  virtual rdcarray<ShaderSourcePrefix> CustomShaderSourcePrefixes() override
+  {
+    return m_Obj.CustomShaderSourcePrefixes();
+  }
+  virtual uint32_t CurSelectedEvent() override { return m_Obj.CurSelectedEvent(); }
+  virtual uint32_t CurEvent() override { return m_Obj.CurEvent(); }
+  virtual const ActionDescription *CurSelectedAction() override
+  {
+    return m_Obj.CurSelectedAction();
+  }
+  virtual const ActionDescription *CurAction() override { return m_Obj.CurAction(); }
+  virtual const ActionDescription *GetFirstAction() override { return m_Obj.GetFirstAction(); }
+  virtual const ActionDescription *GetLastAction() override { return m_Obj.GetLastAction(); }
+  virtual const rdcarray<ActionDescription> &CurRootActions() override
+  {
+    return m_Obj.CurRootActions();
+  }
+  virtual const ResourceDescription *GetResource(ResourceId id) const override
+  {
+    return m_Obj.GetResource(id);
+  }
+  virtual const rdcarray<ResourceDescription> &GetResources() override
+  {
+    return m_Obj.GetResources();
+  }
+  virtual rdcstr GetResourceName(ResourceId id) const override { return m_Obj.GetResourceName(id); }
+  virtual rdcstr GetResourceNameUnsuffixed(ResourceId id) const override
+  {
+    return m_Obj.GetResourceNameUnsuffixed(id);
+  }
+  virtual bool IsAutogeneratedName(ResourceId id) override { return m_Obj.IsAutogeneratedName(id); }
+  virtual bool HasResourceCustomName(ResourceId id) override
+  {
+    return m_Obj.HasResourceCustomName(id);
+  }
+  virtual int32_t ResourceNameCacheID() const override { return m_Obj.ResourceNameCacheID(); }
+  virtual TextureDescription *GetTexture(ResourceId id) override { return m_Obj.GetTexture(id); }
+  virtual const rdcarray<TextureDescription> &GetTextures() override { return m_Obj.GetTextures(); }
+  virtual BufferDescription *GetBuffer(ResourceId id) override { return m_Obj.GetBuffer(id); }
+  virtual DescriptorStoreDescription *GetDescriptorStore(ResourceId id) override
+  {
+    return m_Obj.GetDescriptorStore(id);
+  }
+  virtual const rdcarray<BufferDescription> &GetBuffers() const override
+  {
+    return m_Obj.GetBuffers();
+  }
+  virtual const ActionDescription *GetAction(uint32_t eventId) override
+  {
+    return m_Obj.GetAction(eventId);
+  }
+  virtual void ClearReplayCache() override { return m_Obj.ClearReplayCache(); }
+  virtual bool OpenRGPProfile(const rdcstr &filename) override
+  {
+    return m_Obj.OpenRGPProfile(filename);
+  }
+  virtual IRGPInterop *GetRGPInterop() override { return m_Obj.GetRGPInterop(); }
+  virtual const SDFile &GetStructuredFile() override { return m_Obj.GetStructuredFile(); }
+  virtual WindowingSystem CurWindowingSystem() override { return m_Obj.CurWindowingSystem(); }
+  virtual const rdcarray<DebugMessage> &DebugMessages() override { return m_Obj.DebugMessages(); }
+  virtual int32_t UnreadMessageCount() override { return m_Obj.UnreadMessageCount(); }
+  virtual void MarkMessagesRead() override { return m_Obj.MarkMessagesRead(); }
+  virtual rdcstr GetNotes(const rdcstr &key) override { return m_Obj.GetNotes(key); }
+  virtual rdcarray<EventBookmark> GetBookmarks() override { return m_Obj.GetBookmarks(); }
+  virtual const D3D11Pipe::State *CurD3D11PipelineState() override
+  {
+    return m_Obj.CurD3D11PipelineState();
+  }
+  virtual const D3D12Pipe::State *CurD3D12PipelineState() override
+  {
+    return m_Obj.CurD3D12PipelineState();
+  }
+  virtual const GLPipe::State *CurGLPipelineState() override { return m_Obj.CurGLPipelineState(); }
+  virtual const VKPipe::State *CurVulkanPipelineState() override
+  {
+    return m_Obj.CurVulkanPipelineState();
+  }
+  virtual const PipeState &CurPipelineState() override { return m_Obj.CurPipelineState(); }
+  virtual PersistantConfig &Config() override { return m_Obj.Config(); }
+  //
+  ///////////////////////////////////////////////////////////////////////
+  // functions that invoke onto the UI thread
+  ///////////////////////////////////////////////////////////////////////
+  //
+  virtual void ConnectToRemoteServer(RemoteHost host) override
+  {
+    InvokeVoidFunction(&ICaptureContext::ConnectToRemoteServer, host);
+  }
+  virtual WindowingData CreateWindowingData(QWidget *window) override
+  {
+    return InvokeRetFunction<WindowingData>(&ICaptureContext::CreateWindowingData, window);
+  }
+  virtual void LoadCapture(const rdcstr &capture, const ReplayOptions &opts,
+                           const rdcstr &origFilename, bool temporary, bool local) override
+  {
+    InvokeVoidFunction(&ICaptureContext::LoadCapture, capture, opts, origFilename, temporary, local);
+  }
+  virtual bool SaveCaptureTo(const rdcstr &capture) override
+  {
+    return InvokeRetFunction<bool>(&ICaptureContext::SaveCaptureTo, capture);
+  }
+  virtual void RecompressCapture() override
+  {
+    InvokeVoidFunction(&ICaptureContext::RecompressCapture);
+  }
+  virtual void CloseCapture() override { InvokeVoidFunction(&ICaptureContext::CloseCapture); }
+  virtual IReplayController *GetBlockingController() override
+  {
+    if(!m_Obj.IsCaptureLoaded())
+      return NULL;
+    return &m_ReplayController;
+  }
+  virtual bool ImportCapture(const CaptureFileFormat &fmt, const rdcstr &importfile,
+                             const rdcstr &rdcfile) override
+  {
+    return InvokeRetFunction<bool>(&ICaptureContext::ImportCapture, fmt, importfile, rdcfile);
+  }
+  virtual void ExportCapture(const CaptureFileFormat &fmt, const rdcstr &exportfile) override
+  {
+    InvokeVoidFunction(&ICaptureContext::ExportCapture, fmt, exportfile);
+  }
+  virtual void SetEventID(const rdcarray<ICaptureViewer *> &exclude, uint32_t selectedEventID,
+                          uint32_t eventId, bool force = false) override
+  {
+    InvokeVoidFunction(&ICaptureContext::SetEventID, exclude, selectedEventID, eventId, force);
+  }
+  virtual void RefreshStatus() override { InvokeVoidFunction(&ICaptureContext::RefreshStatus); }
+  virtual bool IsResourceReplaced(ResourceId id) override
+  {
+    return InvokeRetFunction<bool>(&ICaptureContext::IsResourceReplaced, id);
+  }
+  virtual ResourceId GetResourceReplacement(ResourceId id) override
+  {
+    return InvokeRetFunction<ResourceId>(&ICaptureContext::GetResourceReplacement, id);
+  }
+  virtual void RegisterReplacement(ResourceId from, ResourceId to) override
+  {
+    InvokeVoidFunction(&ICaptureContext::RegisterReplacement, from, to);
+  }
+  virtual void UnregisterReplacement(ResourceId id) override
+  {
+    InvokeVoidFunction(&ICaptureContext::UnregisterReplacement, id);
+  }
+  virtual void AddCaptureViewer(ICaptureViewer *viewer) override
+  {
+    InvokeVoidFunction(&ICaptureContext::AddCaptureViewer, viewer);
+  }
+  virtual void RemoveCaptureViewer(ICaptureViewer *viewer) override
+  {
+    InvokeVoidFunction(&ICaptureContext::RemoveCaptureViewer, viewer);
+  }
+  virtual void AddMessages(const rdcarray<DebugMessage> &msgs) override
+  {
+    InvokeVoidFunction(&ICaptureContext::AddMessages, msgs);
+  }
+  virtual void ClearMessages() override { InvokeVoidFunction(&ICaptureContext::ClearMessages); }
+  virtual void SetResourceCustomName(ResourceId id, const rdcstr &name) override
+  {
+    InvokeVoidFunction(&ICaptureContext::SetResourceCustomName, id, name);
+  }
+  virtual void SetNotes(const rdcstr &key, const rdcstr &contents) override
+  {
+    InvokeVoidFunction(&ICaptureContext::SetNotes, key, contents);
+  }
+
+  virtual void SetBookmark(const EventBookmark &mark) override
+  {
+    InvokeVoidFunction(&ICaptureContext::SetBookmark, mark);
+  }
+  virtual void RemoveBookmark(uint32_t EID) override
+  {
+    InvokeVoidFunction(&ICaptureContext::RemoveBookmark, EID);
+  }
+  virtual void EmbedDependentFiles() override
+  {
+    InvokeVoidFunction(&ICaptureContext::EmbedDependentFiles);
+  }
+  virtual void RemoveDependentFiles() override
+  {
+    InvokeVoidFunction(&ICaptureContext::RemoveDependentFiles);
+  }
+  virtual void DelayedCallback(uint32_t milliseconds, std::function<void()> callback) override
+  {
+    if(!GUIInvoke::onUIThread())
+    {
+      PythonContext *scriptContext = m_Shell->GetScriptContext();
+      if(scriptContext)
+        scriptContext->PausePythonThreading();
+      GUIInvoke::call(m_Shell, [this, milliseconds, callback]() {
+        m_Obj.DelayedCallback(milliseconds, callback);
+      });
+      if(scriptContext)
+        scriptContext->ResumePythonThreading();
+      return;
+    }
+
+    m_Obj.DelayedCallback(milliseconds, callback);
+  }
+  virtual IMainWindow *GetMainWindow() override
+  {
+    return WrapInvoker(InvokeRetFunction<IMainWindow *>(&ICaptureContext::GetMainWindow));
+  }
+  virtual IEventBrowser *GetEventBrowser() override
+  {
+    return WrapInvoker(InvokeRetFunction<IEventBrowser *>(&ICaptureContext::GetEventBrowser));
+  }
+  virtual IAPIInspector *GetAPIInspector() override
+  {
+    return WrapInvoker(InvokeRetFunction<IAPIInspector *>(&ICaptureContext::GetAPIInspector));
+  }
+  virtual IAnnotationViewer *GetAnnotationViewer() override
+  {
+    return WrapInvoker(InvokeRetFunction<IAnnotationViewer *>(&ICaptureContext::GetAnnotationViewer));
+  }
+  virtual ITextureViewer *GetTextureViewer() override
+  {
+    return WrapInvoker(InvokeRetFunction<ITextureViewer *>(&ICaptureContext::GetTextureViewer));
+  }
+  virtual IBufferViewer *GetMeshPreview() override
+  {
+    return WrapInvoker(InvokeRetFunction<IBufferViewer *>(&ICaptureContext::GetMeshPreview));
+  }
+  virtual IPipelineStateViewer *GetPipelineViewer() override
+  {
+    return WrapInvoker(InvokeRetFunction<IPipelineStateViewer *>(&ICaptureContext::GetPipelineViewer));
+  }
+  virtual ICaptureDialog *GetCaptureDialog() override
+  {
+    return WrapInvoker(InvokeRetFunction<ICaptureDialog *>(&ICaptureContext::GetCaptureDialog));
+  }
+  virtual IDebugMessageView *GetDebugMessageView() override
+  {
+    return WrapInvoker(InvokeRetFunction<IDebugMessageView *>(&ICaptureContext::GetDebugMessageView));
+  }
+  virtual IDiagnosticLogView *GetDiagnosticLogView() override
+  {
+    return WrapInvoker(
+        InvokeRetFunction<IDiagnosticLogView *>(&ICaptureContext::GetDiagnosticLogView));
+  }
+  virtual ICommentView *GetCommentView() override
+  {
+    return WrapInvoker(InvokeRetFunction<ICommentView *>(&ICaptureContext::GetCommentView));
+  }
+  virtual IPerformanceCounterViewer *GetPerformanceCounterViewer() override
+  {
+    return WrapInvoker(InvokeRetFunction<IPerformanceCounterViewer *>(
+        &ICaptureContext::GetPerformanceCounterViewer));
+  }
+  virtual IStatisticsViewer *GetStatisticsViewer() override
+  {
+    return WrapInvoker(InvokeRetFunction<IStatisticsViewer *>(&ICaptureContext::GetStatisticsViewer));
+  }
+  virtual ITimelineBar *GetTimelineBar() override
+  {
+    return WrapInvoker(InvokeRetFunction<ITimelineBar *>(&ICaptureContext::GetTimelineBar));
+  }
+  virtual IPythonShell *GetPythonShell() override
+  {
+    return WrapInvoker(InvokeRetFunction<IPythonShell *>(&ICaptureContext::GetPythonShell));
+  }
+  virtual IResourceInspector *GetResourceInspector() override
+  {
+    return WrapInvoker(
+        InvokeRetFunction<IResourceInspector *>(&ICaptureContext::GetResourceInspector));
+  }
+  virtual bool HasEventBrowser() override
+  {
+    return InvokeRetFunction<bool>(&ICaptureContext::HasEventBrowser);
+  }
+  virtual bool HasAPIInspector() override
+  {
+    return InvokeRetFunction<bool>(&ICaptureContext::HasAPIInspector);
+  }
+  virtual bool HasAnnotationViewer() override
+  {
+    return InvokeRetFunction<bool>(&ICaptureContext::HasAnnotationViewer);
+  }
+  virtual bool HasTextureViewer() override
+  {
+    return InvokeRetFunction<bool>(&ICaptureContext::HasTextureViewer);
+  }
+  virtual bool HasPipelineViewer() override
+  {
+    return InvokeRetFunction<bool>(&ICaptureContext::HasPipelineViewer);
+  }
+  virtual bool HasMeshPreview() override
+  {
+    return InvokeRetFunction<bool>(&ICaptureContext::HasMeshPreview);
+  }
+  virtual bool HasCaptureDialog() override
+  {
+    return InvokeRetFunction<bool>(&ICaptureContext::HasCaptureDialog);
+  }
+  virtual bool HasDebugMessageView() override
+  {
+    return InvokeRetFunction<bool>(&ICaptureContext::HasDebugMessageView);
+  }
+  virtual bool HasDiagnosticLogView() override
+  {
+    return InvokeRetFunction<bool>(&ICaptureContext::HasDiagnosticLogView);
+  }
+  virtual bool HasCommentView() override
+  {
+    return InvokeRetFunction<bool>(&ICaptureContext::HasCommentView);
+  }
+  virtual bool HasPerformanceCounterViewer() override
+  {
+    return InvokeRetFunction<bool>(&ICaptureContext::HasPerformanceCounterViewer);
+  }
+  virtual bool HasStatisticsViewer() override
+  {
+    return InvokeRetFunction<bool>(&ICaptureContext::HasStatisticsViewer);
+  }
+  virtual bool HasTimelineBar() override
+  {
+    return InvokeRetFunction<bool>(&ICaptureContext::HasTimelineBar);
+  }
+  virtual bool HasPythonShell() override
+  {
+    return InvokeRetFunction<bool>(&ICaptureContext::HasPythonShell);
+  }
+  virtual bool HasResourceInspector() override
+  {
+    return InvokeRetFunction<bool>(&ICaptureContext::HasResourceInspector);
+  }
+
+  virtual void ShowEventBrowser() override
+  {
+    InvokeVoidFunction(&ICaptureContext::ShowEventBrowser);
+  }
+  virtual void ShowAPIInspector() override
+  {
+    InvokeVoidFunction(&ICaptureContext::ShowAPIInspector);
+  }
+  virtual void ShowAnnotationViewer() override
+  {
+    InvokeVoidFunction(&ICaptureContext::ShowAnnotationViewer);
+  }
+  virtual void ShowTextureViewer() override
+  {
+    InvokeVoidFunction(&ICaptureContext::ShowTextureViewer);
+  }
+  virtual void ShowMeshPreview() override { InvokeVoidFunction(&ICaptureContext::ShowMeshPreview); }
+  virtual void ShowPipelineViewer() override
+  {
+    InvokeVoidFunction(&ICaptureContext::ShowPipelineViewer);
+  }
+  virtual void ShowCaptureDialog() override
+  {
+    InvokeVoidFunction(&ICaptureContext::ShowCaptureDialog);
+  }
+  virtual void ShowDebugMessageView() override
+  {
+    InvokeVoidFunction(&ICaptureContext::ShowDebugMessageView);
+  }
+  virtual void ShowDiagnosticLogView() override
+  {
+    InvokeVoidFunction(&ICaptureContext::ShowDiagnosticLogView);
+  }
+  virtual void ShowCommentView() override { InvokeVoidFunction(&ICaptureContext::ShowCommentView); }
+  virtual void ShowPerformanceCounterViewer() override
+  {
+    InvokeVoidFunction(&ICaptureContext::ShowPerformanceCounterViewer);
+  }
+  virtual void ShowStatisticsViewer() override
+  {
+    InvokeVoidFunction(&ICaptureContext::ShowStatisticsViewer);
+  }
+  virtual void ShowTimelineBar() override { InvokeVoidFunction(&ICaptureContext::ShowTimelineBar); }
+  virtual void ShowPythonShell() override { InvokeVoidFunction(&ICaptureContext::ShowPythonShell); }
+  virtual void ShowResourceInspector() override
+  {
+    InvokeVoidFunction(&ICaptureContext::ShowResourceInspector);
+  }
+  virtual IShaderViewer *EditShader(ResourceId id, ShaderStage stage, const rdcstr &entryPoint,
+                                    const rdcstrpairs &files, KnownShaderTool knownTool,
+                                    ShaderEncoding shaderEncoding, ShaderCompileFlags flags,
+                                    IShaderViewer::SaveCallback saveCallback,
+                                    IShaderViewer::RevertCallback revertCallback) override
+  {
+    return InvokeRetFunction<IShaderViewer *>(&ICaptureContext::EditShader, id, stage, entryPoint,
+                                              files, knownTool, shaderEncoding, flags, saveCallback,
+                                              revertCallback);
+  }
+
+  virtual IShaderViewer *DebugShader(const ShaderReflection *shader, ResourceId pipeline,
+                                     ShaderDebugTrace *trace, const rdcstr &debugContext) override
+  {
+    return InvokeRetFunction<IShaderViewer *>(&ICaptureContext::DebugShader, shader, pipeline,
+                                              trace, debugContext);
+  }
+
+  virtual IShaderViewer *ViewShader(const ShaderReflection *shader, ResourceId pipeline) override
+  {
+    return InvokeRetFunction<IShaderViewer *>(&ICaptureContext::ViewShader, shader, pipeline);
+  }
+
+  virtual IShaderMessageViewer *ViewShaderMessages(ShaderStageMask stages) override
+  {
+    return InvokeRetFunction<IShaderMessageViewer *>(&ICaptureContext::ViewShaderMessages, stages);
+  }
+
+  virtual IDescriptorViewer *ViewDescriptorStore(ResourceId id) override
+  {
+    return InvokeRetFunction<IDescriptorViewer *>(&ICaptureContext::ViewDescriptorStore, id);
+  }
+  virtual IDescriptorViewer *ViewDescriptors(const rdcarray<Descriptor> &descriptors,
+                                             const rdcarray<SamplerDescriptor> &samplerDescriptors) override
+  {
+    return InvokeRetFunction<IDescriptorViewer *>(&ICaptureContext::ViewDescriptors, descriptors,
+                                                  samplerDescriptors);
+  }
+
+  virtual IBufferViewer *ViewBuffer(uint64_t byteOffset, uint64_t byteSize, ResourceId id,
+                                    const rdcstr &format = "") override
+  {
+    return InvokeRetFunction<IBufferViewer *>(&ICaptureContext::ViewBuffer, byteOffset, byteSize,
+                                              id, format);
+  }
+
+  virtual IBufferViewer *ViewTextureAsBuffer(ResourceId id, const Subresource &sub,
+                                             const rdcstr &format = "") override
+  {
+    return InvokeRetFunction<IBufferViewer *>(&ICaptureContext::ViewTextureAsBuffer, id, sub, format);
+  }
+
+  virtual IBufferViewer *ViewConstantBuffer(ShaderStage stage, uint32_t slot, uint32_t idx) override
+  {
+    return InvokeRetFunction<IBufferViewer *>(&ICaptureContext::ViewConstantBuffer, stage, slot, idx);
+  }
+
+  virtual IPixelHistoryView *ViewPixelHistory(ResourceId texID, uint32_t x, uint32_t y,
+                                              uint32_t view, const TextureDisplay &display) override
+  {
+    return InvokeRetFunction<IPixelHistoryView *>(&ICaptureContext::ViewPixelHistory, texID, x, y,
+                                                  view, display);
+  }
+
+  virtual QWidget *CreateBuiltinWindow(const rdcstr &objectName) override
+  {
+    return InvokeRetFunction<QWidget *>(&ICaptureContext::CreateBuiltinWindow, objectName);
+  }
+
+  virtual void BuiltinWindowClosed(QWidget *window) override
+  {
+    InvokeVoidFunction(&ICaptureContext::BuiltinWindowClosed, window);
+  }
+
+  virtual void RaiseDockWindow(QWidget *dockWindow) override
+  {
+    InvokeVoidFunction(&ICaptureContext::RaiseDockWindow, dockWindow);
+  }
+
+  virtual void AddDockWindow(QWidget *newWindow, DockReference ref, QWidget *refWindow,
+                             float percentage = 0.5f) override
+  {
+    InvokeVoidFunction(&ICaptureContext::AddDockWindow, newWindow, ref, refWindow, percentage);
+  }
+};
+
+ICaptureContext *MakeCaptureContextInvoker(PythonShell *shell, ICaptureContext &ctx)
+{
+  return new CaptureContextInvoker(shell, ctx);
+}
+
+void FreeCaptureContextInvoker(ICaptureContext *ctx)
+{
+  CaptureContextInvoker *invoker = (CaptureContextInvoker *)ctx;
+  delete invoker;
+}
diff --git a/qrenderdoc/Windows/PythonShell.cpp b/qrenderdoc/Windows/PythonShell.cpp
index 7723c13e7..b4ffdf636 100644
--- a/qrenderdoc/Windows/PythonShell.cpp
+++ b/qrenderdoc/Windows/PythonShell.cpp
@@ -48,1263 +48,6 @@ enum
   FirstExtensionOutputFilter,
 };
 
-// a forwarder that invokes onto the UI thread wherever necessary.
-// Note this does NOT make CaptureContext thread safe. We just invoke for any potentially UI
-// operations. All invokes are blocking, so there can't be any times when the UI thread waits
-// on the python thread.
-template <typename Obj>
-struct UIThreadInvoker : Obj
-{
-  UIThreadInvoker(PythonShell *sh, Obj &o) : m_Shell(sh), m_Obj(o) {}
-  PythonShell *m_Shell;
-  Obj &m_Obj;
-
-  template <typename F, typename... paramTypes>
-  void InvokeVoidFunction(F ptr, paramTypes... params)
-  {
-    if(!GUIInvoke::onUIThread())
-    {
-      PythonContext *scriptContext = m_Shell->GetScriptContext();
-      if(scriptContext)
-        scriptContext->PausePythonThreading();
-      GUIInvoke::blockcall(m_Shell, [this, ptr, params...]() { (m_Obj.*ptr)(params...); });
-      if(scriptContext)
-        scriptContext->ResumePythonThreading();
-      return;
-    }
-
-    (m_Obj.*ptr)(params...);
-  }
-
-  template <typename R, typename F, typename... paramTypes>
-  R InvokeRetFunction(F ptr, paramTypes... params)
-  {
-    if(!GUIInvoke::onUIThread())
-    {
-      R ret;
-      PythonContext *scriptContext = m_Shell->GetScriptContext();
-      if(scriptContext)
-        scriptContext->PausePythonThreading();
-      GUIInvoke::blockcall(m_Shell,
-                           [this, &ret, ptr, params...]() { ret = (m_Obj.*ptr)(params...); });
-      if(scriptContext)
-        scriptContext->ResumePythonThreading();
-      return ret;
-    }
-
-    return (m_Obj.*ptr)(params...);
-  }
-};
-
-struct MiniQtInvoker : UIThreadInvoker<IMiniQtHelper>
-{
-  MiniQtInvoker(PythonShell *shell, IMiniQtHelper &obj) : UIThreadInvoker(shell, obj) {}
-  virtual ~MiniQtInvoker() {}
-  void InvokeOntoUIThread(std::function<void()> callback)
-  {
-    // this function is already thread safe since it's invoking, so just call it directly
-    m_Obj.InvokeOntoUIThread(callback);
-  }
-
-  ///////////////////////////////////////////////////////////////////////
-  // all functions invoke onto the UI thread since they deal with widgets!
-  ///////////////////////////////////////////////////////////////////////
-
-  QWidget *CreateToplevelWidget(const rdcstr &windowTitle, WidgetCallback closed)
-  {
-    return InvokeRetFunction<QWidget *>(&IMiniQtHelper::CreateToplevelWidget, windowTitle, closed);
-  }
-  void CloseToplevelWidget(QWidget *widget)
-  {
-    InvokeVoidFunction(&IMiniQtHelper::CloseToplevelWidget, widget);
-  }
-
-  // widget hierarchy
-
-  void SetWidgetName(QWidget *widget, const rdcstr &name)
-  {
-    InvokeVoidFunction(&IMiniQtHelper::SetWidgetName, widget, name);
-  }
-  rdcstr GetWidgetName(QWidget *widget)
-  {
-    return InvokeRetFunction<rdcstr>(&IMiniQtHelper::GetWidgetName, widget);
-  }
-  rdcstr GetWidgetType(QWidget *widget)
-  {
-    return InvokeRetFunction<rdcstr>(&IMiniQtHelper::GetWidgetType, widget);
-  }
-  QWidget *FindChildByName(QWidget *parent, const rdcstr &name)
-  {
-    return InvokeRetFunction<QWidget *>(&IMiniQtHelper::FindChildByName, parent, name);
-  }
-  QWidget *GetParent(QWidget *widget)
-  {
-    return InvokeRetFunction<QWidget *>(&IMiniQtHelper::GetParent, widget);
-  }
-  int32_t GetNumChildren(QWidget *widget)
-  {
-    return InvokeRetFunction<int32_t>(&IMiniQtHelper::GetNumChildren, widget);
-  }
-  QWidget *GetChild(QWidget *parent, int32_t index)
-  {
-    return InvokeRetFunction<QWidget *>(&IMiniQtHelper::GetChild, parent, index);
-  }
-  void DestroyWidget(QWidget *widget) { InvokeVoidFunction(&IMiniQtHelper::DestroyWidget, widget); }
-  // dialogs
-
-  bool ShowWidgetAsDialog(QWidget *widget)
-  {
-    return InvokeRetFunction<bool>(&IMiniQtHelper::ShowWidgetAsDialog, widget);
-  }
-  void CloseCurrentDialog(bool success)
-  {
-    InvokeVoidFunction(&IMiniQtHelper::CloseCurrentDialog, success);
-  }
-
-  // layout functions
-
-  QWidget *CreateHorizontalContainer()
-  {
-    return InvokeRetFunction<QWidget *>(&IMiniQtHelper::CreateHorizontalContainer);
-  }
-  QWidget *CreateVerticalContainer()
-  {
-    return InvokeRetFunction<QWidget *>(&IMiniQtHelper::CreateVerticalContainer);
-  }
-  QWidget *CreateGridContainer()
-  {
-    return InvokeRetFunction<QWidget *>(&IMiniQtHelper::CreateGridContainer);
-  }
-  QWidget *CreateSpacer(bool horizontal)
-  {
-    return InvokeRetFunction<QWidget *>(&IMiniQtHelper::CreateSpacer, horizontal);
-  }
-  void ClearContainedWidgets(QWidget *parent)
-  {
-    InvokeVoidFunction(&IMiniQtHelper::ClearContainedWidgets, parent);
-  }
-  void AddGridWidget(QWidget *parent, int32_t row, int32_t column, QWidget *child, int32_t rowSpan,
-                     int32_t columnSpan)
-  {
-    InvokeVoidFunction(&IMiniQtHelper::AddGridWidget, parent, row, column, child, rowSpan,
-                       columnSpan);
-  }
-  void AddWidget(QWidget *parent, QWidget *child)
-  {
-    InvokeVoidFunction(&IMiniQtHelper::AddWidget, parent, child);
-  }
-  void InsertWidget(QWidget *parent, int32_t index, QWidget *child)
-  {
-    InvokeVoidFunction(&IMiniQtHelper::InsertWidget, parent, index, child);
-  }
-
-  // widget manipulation
-
-  void SetWidgetText(QWidget *widget, const rdcstr &text)
-  {
-    InvokeVoidFunction(&IMiniQtHelper::SetWidgetText, widget, text);
-  }
-  rdcstr GetWidgetText(QWidget *widget)
-  {
-    return InvokeRetFunction<rdcstr>(&IMiniQtHelper::GetWidgetText, widget);
-  }
-
-  void SetWidgetFont(QWidget *widget, const rdcstr &font, int32_t fontSize, bool bold, bool italic)
-  {
-    InvokeVoidFunction(&IMiniQtHelper::SetWidgetFont, widget, font, fontSize, bold, italic);
-  }
-
-  void SetWidgetEnabled(QWidget *widget, bool enabled)
-  {
-    InvokeVoidFunction(&IMiniQtHelper::SetWidgetEnabled, widget, enabled);
-  }
-  bool IsWidgetEnabled(QWidget *widget)
-  {
-    return InvokeRetFunction<bool>(&IMiniQtHelper::IsWidgetEnabled, widget);
-  }
-  void SetWidgetVisible(QWidget *widget, bool visible)
-  {
-    InvokeVoidFunction(&IMiniQtHelper::SetWidgetVisible, widget, visible);
-  }
-  bool IsWidgetVisible(QWidget *widget)
-  {
-    return InvokeRetFunction<bool>(&IMiniQtHelper::IsWidgetVisible, widget);
-  }
-
-  // specific widgets
-
-  QWidget *CreateGroupBox(bool collapsible)
-  {
-    return InvokeRetFunction<QWidget *>(&IMiniQtHelper::CreateGroupBox, collapsible);
-  }
-
-  QWidget *CreateButton(WidgetCallback pressed)
-  {
-    return InvokeRetFunction<QWidget *>(&IMiniQtHelper::CreateButton, pressed);
-  }
-
-  QWidget *CreateLabel() { return InvokeRetFunction<QWidget *>(&IMiniQtHelper::CreateLabel); }
-  void SetLabelImage(QWidget *widget, const bytebuf &data, int32_t width, int32_t height, bool alpha)
-  {
-    InvokeVoidFunction(&IMiniQtHelper::SetLabelImage, widget, data, width, height, alpha);
-  }
-  QWidget *CreateOutputRenderingWidget()
-  {
-    return InvokeRetFunction<QWidget *>(&IMiniQtHelper::CreateOutputRenderingWidget);
-  }
-  WindowingData GetWidgetWindowingData(QWidget *widget)
-  {
-    return InvokeRetFunction<WindowingData>(&IMiniQtHelper::GetWidgetWindowingData, widget);
-  }
-
-  void SetWidgetReplayOutput(QWidget *widget, IReplayOutput *output)
-  {
-    InvokeVoidFunction(&IMiniQtHelper::SetWidgetReplayOutput, widget, output);
-  }
-
-  void SetWidgetBackgroundColor(QWidget *widget, float red, float green, float blue)
-  {
-    InvokeVoidFunction(&IMiniQtHelper::SetWidgetBackgroundColor, widget, red, green, blue);
-  }
-  QWidget *CreateCheckbox(WidgetCallback changed)
-  {
-    return InvokeRetFunction<QWidget *>(&IMiniQtHelper::CreateCheckbox, changed);
-  }
-  QWidget *CreateRadiobox(WidgetCallback changed)
-  {
-    return InvokeRetFunction<QWidget *>(&IMiniQtHelper::CreateRadiobox, changed);
-  }
-
-  void SetWidgetChecked(QWidget *checkableWidget, bool checked)
-  {
-    InvokeVoidFunction(&IMiniQtHelper::SetWidgetChecked, checkableWidget, checked);
-  }
-  bool IsWidgetChecked(QWidget *checkableWidget)
-  {
-    return InvokeRetFunction<bool>(&IMiniQtHelper::IsWidgetChecked, checkableWidget);
-  }
-
-  QWidget *CreateSpinbox(int32_t decimalPlaces, double step)
-  {
-    return InvokeRetFunction<QWidget *>(&IMiniQtHelper::CreateSpinbox, decimalPlaces, step);
-  }
-
-  void SetSpinboxBounds(QWidget *spinbox, double minVal, double maxVal)
-  {
-    InvokeVoidFunction(&IMiniQtHelper::SetSpinboxBounds, spinbox, minVal, maxVal);
-  }
-  void SetSpinboxValue(QWidget *spinbox, double value)
-  {
-    InvokeVoidFunction(&IMiniQtHelper::SetSpinboxValue, spinbox, value);
-  }
-  double GetSpinboxValue(QWidget *spinbox)
-  {
-    return InvokeRetFunction<double>(&IMiniQtHelper::GetSpinboxValue, spinbox);
-  }
-
-  QWidget *CreateTextBox(bool singleLine, WidgetCallback changed)
-  {
-    return InvokeRetFunction<QWidget *>(&IMiniQtHelper::CreateTextBox, singleLine, changed);
-  }
-
-  QWidget *CreateComboBox(bool editable, WidgetCallback changed)
-  {
-    return InvokeRetFunction<QWidget *>(&IMiniQtHelper::CreateComboBox, editable, changed);
-  }
-
-  void SetComboOptions(QWidget *combo, const rdcarray<rdcstr> &options)
-  {
-    InvokeVoidFunction(&IMiniQtHelper::SetComboOptions, combo, options);
-  }
-
-  size_t GetComboCount(QWidget *combo)
-  {
-    return InvokeRetFunction<size_t>(&IMiniQtHelper::GetComboCount, combo);
-  }
-
-  void SelectComboOption(QWidget *combo, const rdcstr &option)
-  {
-    InvokeVoidFunction(&IMiniQtHelper::SelectComboOption, combo, option);
-  }
-
-  QWidget *CreateProgressBar(bool horizontal)
-  {
-    return InvokeRetFunction<QWidget *>(&IMiniQtHelper::CreateProgressBar, horizontal);
-  }
-
-  void ResetProgressBar(QWidget *pbar)
-  {
-    InvokeVoidFunction(&IMiniQtHelper::ResetProgressBar, pbar);
-  }
-
-  void SetProgressBarValue(QWidget *pbar, int32_t value)
-  {
-    InvokeVoidFunction(&IMiniQtHelper::SetProgressBarValue, pbar, value);
-  }
-
-  void UpdateProgressBarValue(QWidget *pbar, int32_t delta)
-  {
-    InvokeVoidFunction(&IMiniQtHelper::UpdateProgressBarValue, pbar, delta);
-  }
-
-  int32_t GetProgressBarValue(QWidget *pbar)
-  {
-    return InvokeRetFunction<int>(&IMiniQtHelper::GetProgressBarValue, pbar);
-  }
-
-  void SetProgressBarRange(QWidget *pbar, int32_t minimum, int32_t maximum)
-  {
-    InvokeVoidFunction(&IMiniQtHelper::SetProgressBarRange, pbar, minimum, maximum);
-  }
-
-  int32_t GetProgressBarMinimum(QWidget *pbar)
-  {
-    return InvokeRetFunction<int>(&IMiniQtHelper::GetProgressBarMinimum, pbar);
-  }
-
-  int32_t GetProgressBarMaximum(QWidget *pbar)
-  {
-    return InvokeRetFunction<int>(&IMiniQtHelper::GetProgressBarMaximum, pbar);
-  }
-};
-
-struct ExtensionInvoker : UIThreadInvoker<IExtensionManager>
-{
-  MiniQtInvoker *m_MiniQt;
-  ExtensionInvoker(PythonShell *shell, IExtensionManager &obj) : UIThreadInvoker(shell, obj)
-  {
-    m_MiniQt = new MiniQtInvoker(shell, obj.GetMiniQtHelper());
-  }
-  virtual ~ExtensionInvoker() { delete m_MiniQt; }
-  //
-  ///////////////////////////////////////////////////////////////////////
-  // pass-through functions that don't need the UI thread
-  ///////////////////////////////////////////////////////////////////////
-  //
-  rdcarray<ExtensionMetadata> GetInstalledExtensions() { return m_Obj.GetInstalledExtensions(); }
-  rdcarray<rdcstr> GetLoadedExtensions() { return m_Obj.GetLoadedExtensions(); }
-  bool IsExtensionLoaded(rdcstr name) { return m_Obj.IsExtensionLoaded(name); }
-  rdcstr LoadExtension(rdcstr name) { return m_Obj.LoadExtension(name); }
-  bool IsPythonDebuggerConnected() { return m_Obj.IsPythonDebuggerConnected(); }
-  IMiniQtHelper &GetMiniQtHelper() { return *m_MiniQt; }
-  //
-  ///////////////////////////////////////////////////////////////////////
-  // functions that invoke onto the UI thread
-  ///////////////////////////////////////////////////////////////////////
-  //
-  void RegisterWindowMenu(WindowMenu base, const rdcarray<rdcstr> &submenus,
-                          ExtensionCallback callback)
-  {
-    InvokeVoidFunction(&IExtensionManager::RegisterWindowMenu, base, submenus, callback);
-  }
-
-  void RegisterPanelMenu(PanelMenu base, const rdcarray<rdcstr> &submenus, ExtensionCallback callback)
-  {
-    InvokeVoidFunction(&IExtensionManager::RegisterPanelMenu, base, submenus, callback);
-  }
-
-  void RegisterContextMenu(ContextMenu base, const rdcarray<rdcstr> &submenus,
-                           ExtensionCallback callback)
-  {
-    InvokeVoidFunction(&IExtensionManager::RegisterContextMenu, base, submenus, callback);
-  }
-
-  void MessageDialog(const rdcstr &text, const rdcstr &title)
-  {
-    InvokeVoidFunction(&IExtensionManager::MessageDialog, text, title);
-  }
-
-  void ErrorDialog(const rdcstr &text, const rdcstr &title)
-  {
-    InvokeVoidFunction(&IExtensionManager::ErrorDialog, text, title);
-  }
-
-  DialogButton QuestionDialog(const rdcstr &text, const rdcarray<DialogButton> &options,
-                              const rdcstr &title)
-  {
-    return InvokeRetFunction<DialogButton>(&IExtensionManager::QuestionDialog, text, options, title);
-  }
-
-  rdcstr OpenFileName(const rdcstr &caption, const rdcstr &dir, const rdcstr &filter)
-  {
-    return InvokeRetFunction<rdcstr>(&IExtensionManager::OpenFileName, caption, dir, filter);
-  }
-
-  rdcstr OpenDirectoryName(const rdcstr &caption, const rdcstr &dir)
-  {
-    return InvokeRetFunction<rdcstr>(&IExtensionManager::OpenDirectoryName, caption, dir);
-  }
-
-  rdcstr SaveFileName(const rdcstr &caption, const rdcstr &dir, const rdcstr &filter)
-  {
-    return InvokeRetFunction<rdcstr>(&IExtensionManager::SaveFileName, caption, dir, filter);
-  }
-
-  void MenuDisplaying(ContextMenu contextMenu, QMenu *menu, const ExtensionCallbackData &data)
-  {
-    InvokeVoidFunction(
-        (void(IExtensionManager::*)(ContextMenu, QMenu *, const ExtensionCallbackData &)) &
-            IExtensionManager::MenuDisplaying,
-        contextMenu, menu, data);
-  }
-  void MenuDisplaying(PanelMenu panelMenu, QMenu *menu, QWidget *extensionButton,
-                      const ExtensionCallbackData &data)
-  {
-    InvokeVoidFunction(
-        (void(IExtensionManager::*)(PanelMenu, QMenu *, QWidget *, const ExtensionCallbackData &)) &
-            IExtensionManager::MenuDisplaying,
-        panelMenu, menu, extensionButton, data);
-  }
-};
-
-struct ReplayControllerInvoker : IReplayController
-{
-  ReplayControllerInvoker(PythonShell *shell, ICaptureContext &ctx) : m_Shell(shell), m_Ctx(ctx) {}
-  PythonShell *m_Shell;
-  ICaptureContext &m_Ctx;
-
-  template <typename F, typename... paramTypes>
-  void InvokeVoidFunction(F ptr, paramTypes... params)
-  {
-    PythonContext *scriptContext = m_Shell->GetScriptContext();
-    if(scriptContext)
-      scriptContext->PausePythonThreading();
-    m_Ctx.Replay().BlockInvoke(
-        [this, ptr, params...](IReplayController *replay) { (replay->*ptr)(params...); });
-    if(scriptContext)
-      scriptContext->ResumePythonThreading();
-  }
-
-  template <typename R, typename F, typename... paramTypes>
-  R InvokeRetFunction(F ptr, paramTypes... params)
-  {
-    R ret = R();
-    PythonContext *scriptContext = m_Shell->GetScriptContext();
-    if(scriptContext)
-      scriptContext->PausePythonThreading();
-    m_Ctx.Replay().BlockInvoke([this, &ret, ptr, params...](IReplayController *replay) {
-      ret = (replay->*ptr)(params...);
-    });
-    if(scriptContext)
-      scriptContext->ResumePythonThreading();
-    return ret;
-  }
-
-  template <typename R, typename F, typename... paramTypes>
-  R &InvokeRetRefFunction(F ptr, paramTypes... params)
-  {
-    R *ret = NULL;
-    PythonContext *scriptContext = m_Shell->GetScriptContext();
-    if(scriptContext)
-      scriptContext->PausePythonThreading();
-    m_Ctx.Replay().BlockInvoke([this, &ret, ptr, params...](IReplayController *replay) {
-      ret = &(replay->*ptr)(params...);
-    });
-    if(scriptContext)
-      scriptContext->ResumePythonThreading();
-    return *ret;
-  }
-
-  APIProperties GetAPIProperties()
-  {
-    return InvokeRetFunction<APIProperties>(&IReplayController::GetAPIProperties);
-  }
-
-  rdcarray<WindowingSystem> GetSupportedWindowSystems()
-  {
-    return InvokeRetFunction<rdcarray<WindowingSystem>>(&IReplayController::GetSupportedWindowSystems);
-  }
-
-  IReplayOutput *CreateOutput(WindowingData window, ReplayOutputType type)
-  {
-    return InvokeRetFunction<IReplayOutput *>(&IReplayController::CreateOutput, window, type);
-  }
-
-  void Shutdown() {}
-
-  void ReplayLoop(WindowingData window, ResourceId texid) {}
-
-  rdcstr CreateRGPProfile(WindowingData window)
-  {
-    return InvokeRetFunction<rdcstr>(&IReplayController::CreateRGPProfile, window);
-  }
-
-  void CancelReplayLoop() {}
-
-  void FileChanged() {}
-
-  void SetFrameEvent(uint32_t eventId, bool force) {}
-
-  const D3D11Pipe::State *GetD3D11PipelineState()
-  {
-    return InvokeRetFunction<const D3D11Pipe::State *>(&IReplayController::GetD3D11PipelineState);
-  }
-
-  const D3D12Pipe::State *GetD3D12PipelineState()
-  {
-    return InvokeRetFunction<const D3D12Pipe::State *>(&IReplayController::GetD3D12PipelineState);
-  }
-
-  const GLPipe::State *GetGLPipelineState()
-  {
-    return InvokeRetFunction<const GLPipe::State *>(&IReplayController::GetGLPipelineState);
-  }
-
-  const VKPipe::State *GetVulkanPipelineState()
-  {
-    return InvokeRetFunction<const VKPipe::State *>(&IReplayController::GetVulkanPipelineState);
-  }
-
-  const PipeState &GetPipelineState()
-  {
-    return InvokeRetRefFunction<const PipeState>(&IReplayController::GetPipelineState);
-  }
-
-  rdcarray<Descriptor> GetDescriptors(ResourceId descriptorStore,
-                                      const rdcarray<DescriptorRange> &ranges)
-  {
-    return InvokeRetFunction<rdcarray<Descriptor>>(&IReplayController::GetDescriptors,
-                                                   descriptorStore, ranges);
-  }
-
-  rdcarray<SamplerDescriptor> GetSamplerDescriptors(ResourceId descriptorStore,
-                                                    const rdcarray<DescriptorRange> &ranges)
-  {
-    return InvokeRetFunction<rdcarray<SamplerDescriptor>>(&IReplayController::GetSamplerDescriptors,
-                                                          descriptorStore, ranges);
-  }
-
-  const rdcarray<DescriptorAccess> &GetDescriptorAccess()
-  {
-    return InvokeRetRefFunction<const rdcarray<DescriptorAccess>>(
-        &IReplayController::GetDescriptorAccess);
-  }
-
-  rdcarray<DescriptorLogicalLocation> GetDescriptorLocations(ResourceId descriptorStore,
-                                                             const rdcarray<DescriptorRange> &ranges)
-  {
-    return InvokeRetFunction<rdcarray<DescriptorLogicalLocation>>(
-        &IReplayController::GetDescriptorLocations, descriptorStore, ranges);
-  }
-
-  rdcarray<rdcstr> GetDisassemblyTargets(bool withPipeline)
-  {
-    return InvokeRetFunction<rdcarray<rdcstr>>(&IReplayController::GetDisassemblyTargets,
-                                               withPipeline);
-  }
-
-  rdcstr DisassembleShader(ResourceId pipeline, const ShaderReflection *refl, const rdcstr &target)
-  {
-    return InvokeRetFunction<rdcstr>(&IReplayController::DisassembleShader, pipeline, refl, target);
-  }
-
-  void SetCustomShaderIncludes(const rdcarray<rdcstr> &directories) {}
-
-  rdcpair<ResourceId, rdcstr> BuildCustomShader(const rdcstr &entry, ShaderEncoding sourceEncoding,
-                                                bytebuf source,
-                                                const ShaderCompileFlags &compileFlags,
-                                                ShaderStage type)
-  {
-    return InvokeRetFunction<rdcpair<ResourceId, rdcstr>>(
-        &IReplayController::BuildCustomShader, entry, sourceEncoding, source, compileFlags, type);
-  }
-
-  void FreeCustomShader(ResourceId id) {}
-
-  rdcpair<ResourceId, rdcstr> BuildTargetShader(const rdcstr &entry, ShaderEncoding sourceEncoding,
-                                                bytebuf source,
-                                                const ShaderCompileFlags &compileFlags,
-                                                ShaderStage type)
-  {
-    return InvokeRetFunction<rdcpair<ResourceId, rdcstr>>(
-        &IReplayController::BuildTargetShader, entry, sourceEncoding, source, compileFlags, type);
-  }
-
-  rdcarray<ShaderEncoding> GetTargetShaderEncodings()
-  {
-    return InvokeRetFunction<rdcarray<ShaderEncoding>>(&IReplayController::GetTargetShaderEncodings);
-  }
-
-  rdcarray<ShaderEncoding> GetCustomShaderEncodings()
-  {
-    return InvokeRetFunction<rdcarray<ShaderEncoding>>(&IReplayController::GetCustomShaderEncodings);
-  }
-
-  rdcarray<ShaderSourcePrefix> GetCustomShaderSourcePrefixes()
-  {
-    return InvokeRetFunction<rdcarray<ShaderSourcePrefix>>(
-        &IReplayController::GetCustomShaderSourcePrefixes);
-  }
-
-  void ReplaceResource(ResourceId original, ResourceId replacement) {}
-
-  void ClearReplayCache() {}
-
-  void ReloadShaderDebugInformation() {}
-
-  void RemoveReplacement(ResourceId id) {}
-
-  void FreeTargetResource(ResourceId id) {}
-
-  FrameDescription GetFrameInfo()
-  {
-    return InvokeRetFunction<FrameDescription>(&IReplayController::GetFrameInfo);
-  }
-
-  const SDFile &GetStructuredFile()
-  {
-    return InvokeRetRefFunction<const SDFile>(&IReplayController::GetStructuredFile);
-  }
-
-  void AddFakeMarkers() {}
-
-  const rdcarray<ActionDescription> &GetRootActions()
-  {
-    return InvokeRetRefFunction<const rdcarray<ActionDescription>>(&IReplayController::GetRootActions);
-  }
-
-  rdcarray<CounterResult> FetchCounters(const rdcarray<GPUCounter> &counters)
-  {
-    return InvokeRetFunction<rdcarray<CounterResult>>(&IReplayController::FetchCounters, counters);
-  }
-
-  rdcarray<GPUCounter> EnumerateCounters()
-  {
-    return InvokeRetFunction<rdcarray<GPUCounter>>(&IReplayController::EnumerateCounters);
-  }
-
-  CounterDescription DescribeCounter(GPUCounter counter)
-  {
-    return InvokeRetFunction<CounterDescription>(&IReplayController::DescribeCounter, counter);
-  }
-
-  const rdcarray<ResourceDescription> &GetResources()
-  {
-    return InvokeRetRefFunction<const rdcarray<ResourceDescription>>(&IReplayController::GetResources);
-  }
-
-  const rdcarray<TextureDescription> &GetTextures()
-  {
-    return InvokeRetRefFunction<const rdcarray<TextureDescription>>(&IReplayController::GetTextures);
-  }
-
-  const rdcarray<BufferDescription> &GetBuffers()
-  {
-    return InvokeRetRefFunction<const rdcarray<BufferDescription>>(&IReplayController::GetBuffers);
-  }
-
-  const rdcarray<DescriptorStoreDescription> &GetDescriptorStores()
-  {
-    return InvokeRetRefFunction<const rdcarray<DescriptorStoreDescription>>(
-        &IReplayController::GetDescriptorStores);
-  }
-
-  rdcarray<DebugMessage> GetDebugMessages()
-  {
-    return InvokeRetFunction<rdcarray<DebugMessage>>(&IReplayController::GetDebugMessages);
-  }
-
-  ResultDetails GetFatalErrorStatus()
-  {
-    return InvokeRetFunction<ResultDetails>(&IReplayController::GetFatalErrorStatus);
-  }
-
-  rdcarray<ShaderEntryPoint> GetShaderEntryPoints(ResourceId shader)
-  {
-    return InvokeRetFunction<rdcarray<ShaderEntryPoint>>(&IReplayController::GetShaderEntryPoints,
-                                                         shader);
-  }
-
-  const ShaderReflection *GetShader(ResourceId pipeline, ResourceId shader, ShaderEntryPoint entry)
-  {
-    return InvokeRetFunction<const ShaderReflection *>(&IReplayController::GetShader, pipeline,
-                                                       shader, entry);
-  }
-
-  PixelValue PickPixel(ResourceId textureId, uint32_t x, uint32_t y, const Subresource &sub,
-                       CompType typeCast)
-  {
-    return InvokeRetFunction<PixelValue>(&IReplayController::PickPixel, textureId, x, y, sub,
-                                         typeCast);
-  }
-
-  rdcpair<PixelValue, PixelValue> GetMinMax(ResourceId textureId, const Subresource &sub,
-                                            CompType typeCast)
-  {
-    return InvokeRetFunction<rdcpair<PixelValue, PixelValue>>(&IReplayController::GetMinMax,
-                                                              textureId, sub, typeCast);
-  }
-
-  rdcarray<uint32_t> GetHistogram(ResourceId textureId, const Subresource &sub, CompType typeCast,
-                                  float minval, float maxval, const rdcfixedarray<bool, 4> &channels)
-  {
-    return InvokeRetFunction<rdcarray<uint32_t>>(&IReplayController::GetHistogram, textureId, sub,
-                                                 typeCast, minval, maxval, channels);
-  }
-
-  rdcarray<PixelModification> PixelHistory(ResourceId texture, uint32_t x, uint32_t y,
-                                           const Subresource &sub, CompType typeCast)
-  {
-    return InvokeRetFunction<rdcarray<PixelModification>>(&IReplayController::PixelHistory, texture,
-                                                          x, y, sub, typeCast);
-  }
-
-  ShaderDebugTrace *DebugVertex(uint32_t vertid, uint32_t instid, uint32_t idx, uint32_t view)
-  {
-    return InvokeRetFunction<ShaderDebugTrace *>(&IReplayController::DebugVertex, vertid, instid,
-                                                 idx, view);
-  }
-
-  ShaderDebugTrace *DebugPixel(uint32_t x, uint32_t y, const DebugPixelInputs &inputs)
-  {
-    return InvokeRetFunction<ShaderDebugTrace *>(&IReplayController::DebugPixel, x, y, inputs);
-  }
-
-  ShaderDebugTrace *DebugThread(const rdcfixedarray<uint32_t, 3> &groupid,
-                                const rdcfixedarray<uint32_t, 3> &threadid)
-  {
-    return InvokeRetFunction<ShaderDebugTrace *>(&IReplayController::DebugThread, groupid, threadid);
-  }
-
-  ShaderDebugTrace *DebugMeshThread(const rdcfixedarray<uint32_t, 3> &groupid,
-                                    const rdcfixedarray<uint32_t, 3> &threadid)
-  {
-    return InvokeRetFunction<ShaderDebugTrace *>(&IReplayController::DebugMeshThread, groupid,
-                                                 threadid);
-  }
-
-  rdcarray<ShaderDebugState> ContinueDebug(ShaderDebugger *debugger)
-  {
-    return InvokeRetFunction<rdcarray<ShaderDebugState>>(&IReplayController::ContinueDebug, debugger);
-  }
-
-  void FreeTrace(ShaderDebugTrace *trace)
-  {
-    return InvokeVoidFunction(&IReplayController::FreeTrace, trace);
-  }
-
-  rdcarray<EventUsage> GetUsage(ResourceId id)
-  {
-    return InvokeRetFunction<rdcarray<EventUsage>>(&IReplayController::GetUsage, id);
-  }
-
-  rdcarray<ShaderVariable> GetCBufferVariableContents(ResourceId pipeline, ResourceId shader,
-                                                      ShaderStage stage, const rdcstr &entryPoint,
-                                                      uint32_t cbufslot, ResourceId buffer,
-                                                      uint64_t offset, uint64_t length)
-  {
-    return InvokeRetFunction<rdcarray<ShaderVariable>>(
-        &IReplayController::GetCBufferVariableContents, pipeline, shader, stage, entryPoint,
-        cbufslot, buffer, offset, length);
-  }
-
-  ResultDetails SaveTexture(const TextureSave &saveData, const rdcstr &path)
-  {
-    return InvokeRetFunction<ResultDetails>(&IReplayController::SaveTexture, saveData, path);
-  }
-
-  MeshFormat GetPostVSData(uint32_t instance, uint32_t view, MeshDataStage stage)
-  {
-    return InvokeRetFunction<MeshFormat>(&IReplayController::GetPostVSData, instance, view, stage);
-  }
-
-  bytebuf GetBufferData(ResourceId buff, uint64_t offset, uint64_t len)
-  {
-    return InvokeRetFunction<bytebuf>(&IReplayController::GetBufferData, buff, offset, len);
-  }
-
-  bytebuf GetTextureData(ResourceId tex, const Subresource &sub)
-  {
-    return InvokeRetFunction<bytebuf>(&IReplayController::GetTextureData, tex, sub);
-  }
-};
-
-struct CaptureContextInvoker : UIThreadInvoker<ICaptureContext>
-{
-  ExtensionInvoker *m_Ext;
-  ReplayControllerInvoker m_ReplayController;
-  CaptureContextInvoker(PythonShell *shell, ICaptureContext &obj)
-      : UIThreadInvoker(shell, obj), m_ReplayController(shell, obj)
-  {
-    m_Ext = new ExtensionInvoker(shell, obj.Extensions());
-  }
-  virtual ~CaptureContextInvoker() { delete m_Ext; }
-  //
-  ///////////////////////////////////////////////////////////////////////
-  // pass-through functions that don't need the UI thread
-  ///////////////////////////////////////////////////////////////////////
-  //
-  virtual rdcstr TempCaptureFilename(const rdcstr &appname) override
-  {
-    return m_Obj.TempCaptureFilename(appname);
-  }
-  virtual IExtensionManager &Extensions() override { return *m_Ext; }
-  virtual IReplayManager &Replay() override { return m_Obj.Replay(); }
-  virtual bool IsCaptureLoaded() override { return m_Obj.IsCaptureLoaded(); }
-  virtual bool IsCaptureLocal() override { return m_Obj.IsCaptureLocal(); }
-  virtual bool IsCaptureTemporary() override { return m_Obj.IsCaptureTemporary(); }
-  virtual bool IsCaptureLoading() override { return m_Obj.IsCaptureLoading(); }
-  virtual ResultDetails GetFatalError() override { return m_Obj.GetFatalError(); }
-  virtual rdcstr GetCaptureFilename() override { return m_Obj.GetCaptureFilename(); }
-  virtual CaptureModifications GetCaptureModifications() override
-  {
-    return m_Obj.GetCaptureModifications();
-  }
-  virtual FrameDescription FrameInfo() override { return m_Obj.FrameInfo(); }
-  virtual APIProperties APIProps() override { return m_Obj.APIProps(); }
-  virtual rdcarray<ShaderEncoding> TargetShaderEncodings() override
-  {
-    return m_Obj.TargetShaderEncodings();
-  }
-  virtual rdcarray<ShaderEncoding> CustomShaderEncodings() override
-  {
-    return m_Obj.CustomShaderEncodings();
-  }
-  virtual rdcarray<ShaderSourcePrefix> CustomShaderSourcePrefixes() override
-  {
-    return m_Obj.CustomShaderSourcePrefixes();
-  }
-  virtual uint32_t CurSelectedEvent() override { return m_Obj.CurSelectedEvent(); }
-  virtual uint32_t CurEvent() override { return m_Obj.CurEvent(); }
-  virtual const ActionDescription *CurSelectedAction() override
-  {
-    return m_Obj.CurSelectedAction();
-  }
-  virtual const ActionDescription *CurAction() override { return m_Obj.CurAction(); }
-  virtual const ActionDescription *GetFirstAction() override { return m_Obj.GetFirstAction(); }
-  virtual const ActionDescription *GetLastAction() override { return m_Obj.GetLastAction(); }
-  virtual const rdcarray<ActionDescription> &CurRootActions() override
-  {
-    return m_Obj.CurRootActions();
-  }
-  virtual const ResourceDescription *GetResource(ResourceId id) const override
-  {
-    return m_Obj.GetResource(id);
-  }
-  virtual const rdcarray<ResourceDescription> &GetResources() override
-  {
-    return m_Obj.GetResources();
-  }
-  virtual rdcstr GetResourceName(ResourceId id) const override { return m_Obj.GetResourceName(id); }
-  virtual rdcstr GetResourceNameUnsuffixed(ResourceId id) const override
-  {
-    return m_Obj.GetResourceNameUnsuffixed(id);
-  }
-  virtual bool IsAutogeneratedName(ResourceId id) override { return m_Obj.IsAutogeneratedName(id); }
-  virtual bool HasResourceCustomName(ResourceId id) override
-  {
-    return m_Obj.HasResourceCustomName(id);
-  }
-  virtual int32_t ResourceNameCacheID() const override { return m_Obj.ResourceNameCacheID(); }
-  virtual TextureDescription *GetTexture(ResourceId id) override { return m_Obj.GetTexture(id); }
-  virtual const rdcarray<TextureDescription> &GetTextures() override { return m_Obj.GetTextures(); }
-  virtual BufferDescription *GetBuffer(ResourceId id) override { return m_Obj.GetBuffer(id); }
-  virtual DescriptorStoreDescription *GetDescriptorStore(ResourceId id) override
-  {
-    return m_Obj.GetDescriptorStore(id);
-  }
-  virtual const rdcarray<BufferDescription> &GetBuffers() const override
-  {
-    return m_Obj.GetBuffers();
-  }
-  virtual const ActionDescription *GetAction(uint32_t eventId) override
-  {
-    return m_Obj.GetAction(eventId);
-  }
-  virtual void ClearReplayCache() override { return m_Obj.ClearReplayCache(); }
-  virtual bool OpenRGPProfile(const rdcstr &filename) override
-  {
-    return m_Obj.OpenRGPProfile(filename);
-  }
-  virtual IRGPInterop *GetRGPInterop() override { return m_Obj.GetRGPInterop(); }
-  virtual const SDFile &GetStructuredFile() override { return m_Obj.GetStructuredFile(); }
-  virtual WindowingSystem CurWindowingSystem() override { return m_Obj.CurWindowingSystem(); }
-  virtual const rdcarray<DebugMessage> &DebugMessages() override { return m_Obj.DebugMessages(); }
-  virtual int32_t UnreadMessageCount() override { return m_Obj.UnreadMessageCount(); }
-  virtual void MarkMessagesRead() override { return m_Obj.MarkMessagesRead(); }
-  virtual rdcstr GetNotes(const rdcstr &key) override { return m_Obj.GetNotes(key); }
-  virtual rdcarray<EventBookmark> GetBookmarks() override { return m_Obj.GetBookmarks(); }
-  virtual const D3D11Pipe::State *CurD3D11PipelineState() override
-  {
-    return m_Obj.CurD3D11PipelineState();
-  }
-  virtual const D3D12Pipe::State *CurD3D12PipelineState() override
-  {
-    return m_Obj.CurD3D12PipelineState();
-  }
-  virtual const GLPipe::State *CurGLPipelineState() override { return m_Obj.CurGLPipelineState(); }
-  virtual const VKPipe::State *CurVulkanPipelineState() override
-  {
-    return m_Obj.CurVulkanPipelineState();
-  }
-  virtual const PipeState &CurPipelineState() override { return m_Obj.CurPipelineState(); }
-  virtual PersistantConfig &Config() override { return m_Obj.Config(); }
-  //
-  ///////////////////////////////////////////////////////////////////////
-  // functions that invoke onto the UI thread
-  ///////////////////////////////////////////////////////////////////////
-  //
-  virtual void ConnectToRemoteServer(RemoteHost host) override
-  {
-    InvokeVoidFunction(&ICaptureContext::ConnectToRemoteServer, host);
-  }
-  virtual WindowingData CreateWindowingData(QWidget *window) override
-  {
-    return InvokeRetFunction<WindowingData>(&ICaptureContext::CreateWindowingData, window);
-  }
-  virtual void LoadCapture(const rdcstr &capture, const ReplayOptions &opts,
-                           const rdcstr &origFilename, bool temporary, bool local) override
-  {
-    InvokeVoidFunction(&ICaptureContext::LoadCapture, capture, opts, origFilename, temporary, local);
-  }
-  virtual bool SaveCaptureTo(const rdcstr &capture) override
-  {
-    return InvokeRetFunction<bool>(&ICaptureContext::SaveCaptureTo, capture);
-  }
-  virtual void RecompressCapture() override
-  {
-    InvokeVoidFunction(&ICaptureContext::RecompressCapture);
-  }
-  virtual void CloseCapture() override { InvokeVoidFunction(&ICaptureContext::CloseCapture); }
-  virtual IReplayController *GetBlockingController() override
-  {
-    if(!m_Obj.IsCaptureLoaded())
-      return NULL;
-    return &m_ReplayController;
-  }
-  virtual bool ImportCapture(const CaptureFileFormat &fmt, const rdcstr &importfile,
-                             const rdcstr &rdcfile) override
-  {
-    return InvokeRetFunction<bool>(&ICaptureContext::ImportCapture, fmt, importfile, rdcfile);
-  }
-  virtual void ExportCapture(const CaptureFileFormat &fmt, const rdcstr &exportfile) override
-  {
-    InvokeVoidFunction(&ICaptureContext::ExportCapture, fmt, exportfile);
-  }
-  virtual void SetEventID(const rdcarray<ICaptureViewer *> &exclude, uint32_t selectedEventID,
-                          uint32_t eventId, bool force = false) override
-  {
-    InvokeVoidFunction(&ICaptureContext::SetEventID, exclude, selectedEventID, eventId, force);
-  }
-  virtual void RefreshStatus() override { InvokeVoidFunction(&ICaptureContext::RefreshStatus); }
-  virtual bool IsResourceReplaced(ResourceId id) override
-  {
-    return InvokeRetFunction<bool>(&ICaptureContext::IsResourceReplaced, id);
-  }
-  virtual ResourceId GetResourceReplacement(ResourceId id) override
-  {
-    return InvokeRetFunction<ResourceId>(&ICaptureContext::GetResourceReplacement, id);
-  }
-  virtual void RegisterReplacement(ResourceId from, ResourceId to) override
-  {
-    InvokeVoidFunction(&ICaptureContext::RegisterReplacement, from, to);
-  }
-  virtual void UnregisterReplacement(ResourceId id) override
-  {
-    InvokeVoidFunction(&ICaptureContext::UnregisterReplacement, id);
-  }
-  virtual void AddCaptureViewer(ICaptureViewer *viewer) override
-  {
-    InvokeVoidFunction(&ICaptureContext::AddCaptureViewer, viewer);
-  }
-  virtual void RemoveCaptureViewer(ICaptureViewer *viewer) override
-  {
-    InvokeVoidFunction(&ICaptureContext::RemoveCaptureViewer, viewer);
-  }
-  virtual void AddMessages(const rdcarray<DebugMessage> &msgs) override
-  {
-    InvokeVoidFunction(&ICaptureContext::AddMessages, msgs);
-  }
-  virtual void ClearMessages() override { InvokeVoidFunction(&ICaptureContext::ClearMessages); }
-  virtual void SetResourceCustomName(ResourceId id, const rdcstr &name) override
-  {
-    InvokeVoidFunction(&ICaptureContext::SetResourceCustomName, id, name);
-  }
-  virtual void SetNotes(const rdcstr &key, const rdcstr &contents) override
-  {
-    InvokeVoidFunction(&ICaptureContext::SetNotes, key, contents);
-  }
-
-  virtual void SetBookmark(const EventBookmark &mark) override
-  {
-    InvokeVoidFunction(&ICaptureContext::SetBookmark, mark);
-  }
-  virtual void RemoveBookmark(uint32_t EID) override
-  {
-    InvokeVoidFunction(&ICaptureContext::RemoveBookmark, EID);
-  }
-  virtual void EmbedDependentFiles() override
-  {
-    InvokeVoidFunction(&ICaptureContext::EmbedDependentFiles);
-  }
-  virtual void RemoveDependentFiles() override
-  {
-    InvokeVoidFunction(&ICaptureContext::RemoveDependentFiles);
-  }
-  virtual void DelayedCallback(uint32_t milliseconds, std::function<void()> callback) override
-  {
-    InvokeVoidFunction(&ICaptureContext::DelayedCallback, milliseconds, callback);
-  }
-  virtual IMainWindow *GetMainWindow() override
-  {
-    return InvokeRetFunction<IMainWindow *>(&ICaptureContext::GetMainWindow);
-  }
-  virtual IEventBrowser *GetEventBrowser() override
-  {
-    return InvokeRetFunction<IEventBrowser *>(&ICaptureContext::GetEventBrowser);
-  }
-  virtual IAPIInspector *GetAPIInspector() override
-  {
-    return InvokeRetFunction<IAPIInspector *>(&ICaptureContext::GetAPIInspector);
-  }
-  virtual IAnnotationViewer *GetAnnotationViewer() override
-  {
-    return InvokeRetFunction<IAnnotationViewer *>(&ICaptureContext::GetAnnotationViewer);
-  }
-  virtual ITextureViewer *GetTextureViewer() override
-  {
-    return InvokeRetFunction<ITextureViewer *>(&ICaptureContext::GetTextureViewer);
-  }
-  virtual IBufferViewer *GetMeshPreview() override
-  {
-    return InvokeRetFunction<IBufferViewer *>(&ICaptureContext::GetMeshPreview);
-  }
-  virtual IPipelineStateViewer *GetPipelineViewer() override
-  {
-    return InvokeRetFunction<IPipelineStateViewer *>(&ICaptureContext::GetPipelineViewer);
-  }
-  virtual ICaptureDialog *GetCaptureDialog() override
-  {
-    return InvokeRetFunction<ICaptureDialog *>(&ICaptureContext::GetCaptureDialog);
-  }
-  virtual IDebugMessageView *GetDebugMessageView() override
-  {
-    return InvokeRetFunction<IDebugMessageView *>(&ICaptureContext::GetDebugMessageView);
-  }
-  virtual IDiagnosticLogView *GetDiagnosticLogView() override
-  {
-    return InvokeRetFunction<IDiagnosticLogView *>(&ICaptureContext::GetDiagnosticLogView);
-  }
-  virtual ICommentView *GetCommentView() override
-  {
-    return InvokeRetFunction<ICommentView *>(&ICaptureContext::GetCommentView);
-  }
-  virtual IPerformanceCounterViewer *GetPerformanceCounterViewer() override
-  {
-    return InvokeRetFunction<IPerformanceCounterViewer *>(
-        &ICaptureContext::GetPerformanceCounterViewer);
-  }
-  virtual IStatisticsViewer *GetStatisticsViewer() override
-  {
-    return InvokeRetFunction<IStatisticsViewer *>(&ICaptureContext::GetStatisticsViewer);
-  }
-  virtual ITimelineBar *GetTimelineBar() override
-  {
-    return InvokeRetFunction<ITimelineBar *>(&ICaptureContext::GetTimelineBar);
-  }
-  virtual IPythonShell *GetPythonShell() override
-  {
-    return InvokeRetFunction<IPythonShell *>(&ICaptureContext::GetPythonShell);
-  }
-  virtual IResourceInspector *GetResourceInspector() override
-  {
-    return InvokeRetFunction<IResourceInspector *>(&ICaptureContext::GetResourceInspector);
-  }
-  virtual bool HasEventBrowser() override
-  {
-    return InvokeRetFunction<bool>(&ICaptureContext::HasEventBrowser);
-  }
-  virtual bool HasAPIInspector() override
-  {
-    return InvokeRetFunction<bool>(&ICaptureContext::HasAPIInspector);
-  }
-  virtual bool HasAnnotationViewer() override
-  {
-    return InvokeRetFunction<bool>(&ICaptureContext::HasAnnotationViewer);
-  }
-  virtual bool HasTextureViewer() override
-  {
-    return InvokeRetFunction<bool>(&ICaptureContext::HasTextureViewer);
-  }
-  virtual bool HasPipelineViewer() override
-  {
-    return InvokeRetFunction<bool>(&ICaptureContext::HasPipelineViewer);
-  }
-  virtual bool HasMeshPreview() override
-  {
-    return InvokeRetFunction<bool>(&ICaptureContext::HasMeshPreview);
-  }
-  virtual bool HasCaptureDialog() override
-  {
-    return InvokeRetFunction<bool>(&ICaptureContext::HasCaptureDialog);
-  }
-  virtual bool HasDebugMessageView() override
-  {
-    return InvokeRetFunction<bool>(&ICaptureContext::HasDebugMessageView);
-  }
-  virtual bool HasDiagnosticLogView() override
-  {
-    return InvokeRetFunction<bool>(&ICaptureContext::HasDiagnosticLogView);
-  }
-  virtual bool HasCommentView() override
-  {
-    return InvokeRetFunction<bool>(&ICaptureContext::HasCommentView);
-  }
-  virtual bool HasPerformanceCounterViewer() override
-  {
-    return InvokeRetFunction<bool>(&ICaptureContext::HasPerformanceCounterViewer);
-  }
-  virtual bool HasStatisticsViewer() override
-  {
-    return InvokeRetFunction<bool>(&ICaptureContext::HasStatisticsViewer);
-  }
-  virtual bool HasTimelineBar() override
-  {
-    return InvokeRetFunction<bool>(&ICaptureContext::HasTimelineBar);
-  }
-  virtual bool HasPythonShell() override
-  {
-    return InvokeRetFunction<bool>(&ICaptureContext::HasPythonShell);
-  }
-  virtual bool HasResourceInspector() override
-  {
-    return InvokeRetFunction<bool>(&ICaptureContext::HasResourceInspector);
-  }
-
-  virtual void ShowEventBrowser() override
-  {
-    InvokeVoidFunction(&ICaptureContext::ShowEventBrowser);
-  }
-  virtual void ShowAPIInspector() override
-  {
-    InvokeVoidFunction(&ICaptureContext::ShowAPIInspector);
-  }
-  virtual void ShowAnnotationViewer() override
-  {
-    InvokeVoidFunction(&ICaptureContext::ShowAnnotationViewer);
-  }
-  virtual void ShowTextureViewer() override
-  {
-    InvokeVoidFunction(&ICaptureContext::ShowTextureViewer);
-  }
-  virtual void ShowMeshPreview() override { InvokeVoidFunction(&ICaptureContext::ShowMeshPreview); }
-  virtual void ShowPipelineViewer() override
-  {
-    InvokeVoidFunction(&ICaptureContext::ShowPipelineViewer);
-  }
-  virtual void ShowCaptureDialog() override
-  {
-    InvokeVoidFunction(&ICaptureContext::ShowCaptureDialog);
-  }
-  virtual void ShowDebugMessageView() override
-  {
-    InvokeVoidFunction(&ICaptureContext::ShowDebugMessageView);
-  }
-  virtual void ShowDiagnosticLogView() override
-  {
-    InvokeVoidFunction(&ICaptureContext::ShowDiagnosticLogView);
-  }
-  virtual void ShowCommentView() override { InvokeVoidFunction(&ICaptureContext::ShowCommentView); }
-  virtual void ShowPerformanceCounterViewer() override
-  {
-    InvokeVoidFunction(&ICaptureContext::ShowPerformanceCounterViewer);
-  }
-  virtual void ShowStatisticsViewer() override
-  {
-    InvokeVoidFunction(&ICaptureContext::ShowStatisticsViewer);
-  }
-  virtual void ShowTimelineBar() override { InvokeVoidFunction(&ICaptureContext::ShowTimelineBar); }
-  virtual void ShowPythonShell() override { InvokeVoidFunction(&ICaptureContext::ShowPythonShell); }
-  virtual void ShowResourceInspector() override
-  {
-    InvokeVoidFunction(&ICaptureContext::ShowResourceInspector);
-  }
-  virtual IShaderViewer *EditShader(ResourceId id, ShaderStage stage, const rdcstr &entryPoint,
-                                    const rdcstrpairs &files, KnownShaderTool knownTool,
-                                    ShaderEncoding shaderEncoding, ShaderCompileFlags flags,
-                                    IShaderViewer::SaveCallback saveCallback,
-                                    IShaderViewer::RevertCallback revertCallback) override
-  {
-    return InvokeRetFunction<IShaderViewer *>(&ICaptureContext::EditShader, id, stage, entryPoint,
-                                              files, knownTool, shaderEncoding, flags, saveCallback,
-                                              revertCallback);
-  }
-
-  virtual IShaderViewer *DebugShader(const ShaderReflection *shader, ResourceId pipeline,
-                                     ShaderDebugTrace *trace, const rdcstr &debugContext) override
-  {
-    return InvokeRetFunction<IShaderViewer *>(&ICaptureContext::DebugShader, shader, pipeline,
-                                              trace, debugContext);
-  }
-
-  virtual IShaderViewer *ViewShader(const ShaderReflection *shader, ResourceId pipeline) override
-  {
-    return InvokeRetFunction<IShaderViewer *>(&ICaptureContext::ViewShader, shader, pipeline);
-  }
-
-  virtual IShaderMessageViewer *ViewShaderMessages(ShaderStageMask stages) override
-  {
-    return InvokeRetFunction<IShaderMessageViewer *>(&ICaptureContext::ViewShaderMessages, stages);
-  }
-
-  virtual IDescriptorViewer *ViewDescriptorStore(ResourceId id) override
-  {
-    return InvokeRetFunction<IDescriptorViewer *>(&ICaptureContext::ViewDescriptorStore, id);
-  }
-  virtual IDescriptorViewer *ViewDescriptors(const rdcarray<Descriptor> &descriptors,
-                                             const rdcarray<SamplerDescriptor> &samplerDescriptors) override
-  {
-    return InvokeRetFunction<IDescriptorViewer *>(&ICaptureContext::ViewDescriptors, descriptors,
-                                                  samplerDescriptors);
-  }
-
-  virtual IBufferViewer *ViewBuffer(uint64_t byteOffset, uint64_t byteSize, ResourceId id,
-                                    const rdcstr &format = "") override
-  {
-    return InvokeRetFunction<IBufferViewer *>(&ICaptureContext::ViewBuffer, byteOffset, byteSize,
-                                              id, format);
-  }
-
-  virtual IBufferViewer *ViewTextureAsBuffer(ResourceId id, const Subresource &sub,
-                                             const rdcstr &format = "") override
-  {
-    return InvokeRetFunction<IBufferViewer *>(&ICaptureContext::ViewTextureAsBuffer, id, sub, format);
-  }
-
-  virtual IBufferViewer *ViewConstantBuffer(ShaderStage stage, uint32_t slot, uint32_t idx) override
-  {
-    return InvokeRetFunction<IBufferViewer *>(&ICaptureContext::ViewConstantBuffer, stage, slot, idx);
-  }
-
-  virtual IPixelHistoryView *ViewPixelHistory(ResourceId texID, uint32_t x, uint32_t y,
-                                              uint32_t view, const TextureDisplay &display) override
-  {
-    return InvokeRetFunction<IPixelHistoryView *>(&ICaptureContext::ViewPixelHistory, texID, x, y,
-                                                  view, display);
-  }
-
-  virtual QWidget *CreateBuiltinWindow(const rdcstr &objectName) override
-  {
-    return InvokeRetFunction<QWidget *>(&ICaptureContext::CreateBuiltinWindow, objectName);
-  }
-
-  virtual void BuiltinWindowClosed(QWidget *window) override
-  {
-    InvokeVoidFunction(&ICaptureContext::BuiltinWindowClosed, window);
-  }
-
-  virtual void RaiseDockWindow(QWidget *dockWindow) override
-  {
-    InvokeVoidFunction(&ICaptureContext::RaiseDockWindow, dockWindow);
-  }
-
-  virtual void AddDockWindow(QWidget *newWindow, DockReference ref, QWidget *refWindow,
-                             float percentage = 0.5f) override
-  {
-    InvokeVoidFunction(&ICaptureContext::AddDockWindow, newWindow, ref, refWindow, percentage);
-  }
-};
-
 void updateEditorTitle(ScintillaEdit *editor);
 
 void setEditorFilename(ScintillaEdit *editor, QString filename)
@@ -1412,12 +155,16 @@ bool EditorWrapper::checkAllowClose()
   return true;
 }
 
+// See PythonInvokers.cpp
+ICaptureContext *MakeCaptureContextInvoker(PythonShell *shell, ICaptureContext &ctx);
+void FreeCaptureContextInvoker(ICaptureContext *ctx);
+
 PythonShell::PythonShell(ICaptureContext &ctx, QWidget *parent)
     : QFrame(parent), ui(new Ui::PythonShell), m_Ctx(ctx)
 {
   ui->setupUi(this);
 
-  m_ThreadCtx = new CaptureContextInvoker(this, m_Ctx);
+  m_ThreadCtx = MakeCaptureContextInvoker(this, m_Ctx);
 
   QObject::connect(ui->lineInput, &RDLineEdit::keyPress, this, &PythonShell::interactive_keypress);
   QObject::connect(ui->helpSearch, &RDLineEdit::keyPress, this, &PythonShell::helpSearch_keypress);
@@ -1647,7 +394,7 @@ PythonShell::~PythonShell()
   completionContext->Finish();
   interactiveContext->Finish();
 
-  delete m_ThreadCtx;
+  FreeCaptureContextInvoker(m_ThreadCtx);
 
   delete ui;
 }
@@ -3082,5 +1829,5 @@ PythonContext *PythonShell::newContext()
 
 void PythonShell::setGlobals(PythonContext *ret)
 {
-  ret->setGlobal("pyrenderdoc", (ICaptureContext *)m_ThreadCtx);
+  ret->setGlobal("pyrenderdoc", m_ThreadCtx);
 }
diff --git a/qrenderdoc/Windows/PythonShell.h b/qrenderdoc/Windows/PythonShell.h
index f49facfa9..80cfe97bb 100644
--- a/qrenderdoc/Windows/PythonShell.h
+++ b/qrenderdoc/Windows/PythonShell.h
@@ -133,7 +133,7 @@ private slots:
 private:
   Ui::PythonShell *ui;
   ICaptureContext &m_Ctx;
-  CaptureContextInvoker *m_ThreadCtx = NULL;
+  ICaptureContext *m_ThreadCtx = NULL;
 
   ScintillaEdit *runningScriptEditor = NULL;
 
diff --git a/qrenderdoc/qrenderdoc.pro b/qrenderdoc/qrenderdoc.pro
index 5fa774ccf..87982314a 100644
--- a/qrenderdoc/qrenderdoc.pro
+++ b/qrenderdoc/qrenderdoc.pro
@@ -177,6 +177,7 @@ SOURCES += Code/qrenderdoc.cpp \
     Code/Resources.cpp \
     Code/RGPInterop.cpp \
     Code/pyrenderdoc/PythonContext.cpp \
+    Code/pyrenderdoc/PythonInvokers.cpp \
     Code/Interface/QRDInterface.cpp \
     Code/Interface/Analytics.cpp \
     Code/Interface/ShaderProcessingTool.cpp \
diff --git a/qrenderdoc/qrenderdoc_local.vcxproj b/qrenderdoc/qrenderdoc_local.vcxproj
index b63aa1c79..92ea56853 100644
--- a/qrenderdoc/qrenderdoc_local.vcxproj
+++ b/qrenderdoc/qrenderdoc_local.vcxproj
@@ -602,6 +602,7 @@
     </ClCompile>
     <ClCompile Include="Code\qprocessinfo.cpp" />
     <ClCompile Include="Code\pyrenderdoc\PythonContext.cpp" />
+    <ClCompile Include="Code\pyrenderdoc\PythonInvokers.cpp" />
     <ClCompile Include="Code\QRDUtils.cpp" />
     <ClCompile Include="Code\MiniQtHelper.cpp" />
     <ClCompile Include="Code\Resources.cpp" />
diff --git a/qrenderdoc/qrenderdoc_local.vcxproj.filters b/qrenderdoc/qrenderdoc_local.vcxproj.filters
index 67bd04742..e77bd2d9b 100644
--- a/qrenderdoc/qrenderdoc_local.vcxproj.filters
+++ b/qrenderdoc/qrenderdoc_local.vcxproj.filters
@@ -582,6 +582,9 @@
     <ClCompile Include="Code\pyrenderdoc\PythonContext.cpp">
       <Filter>Code\pyrenderdoc</Filter>
     </ClCompile>
+    <ClCompile Include="Code\pyrenderdoc\PythonInvokers.cpp">
+      <Filter>Code\pyrenderdoc</Filter>
+    </ClCompile>
     <ClCompile Include="$(IntDir)generated\qrenderdoc_python.cxx">
       <Filter>Generated Files</Filter>
     </ClCompile>