Add functionality for overlay tweaking & manual capturing by apps

* The functionality is exposed via dllexported functions so that apps can
  call it to tweak renderdoc's behaviour when injects.
  1) Can now turn bits of the overlay off, or hide it entirely.
  2) Can also manually start and stop a capture on a given window. This
     skips the need for swapping between active swapchains, and allows the
     app to define the exact region of D3D11 calls to be captured (could in
     fact be many frames).
     The window provided determines the swapchain used for thumbnail, and
     also implicitly specifies the device to be used for capture.

renderdoc/core/core.cpp

@@ -88,6 +88,8 @@ RenderDoc::RenderDoc()
 	m_ProgressPtr = NULL;
 	
 	m_ExHandler = NULL;
+
+	m_Overlay = eOverlay_Default;
 	
 	m_RemoteServerThreadShutdown = false;
 	m_RemoteClientThreadShutdown = false;
@@ -203,6 +205,42 @@ RenderDoc::~RenderDoc()
 	RDCLOGDELETE();
 }
 
+void RenderDoc::StartFrameCapture(void *wnd)
+{
+	auto it = m_WindowFrameCapturers.find(wnd);
+	if(it == m_WindowFrameCapturers.end())
+	{
+		RDCERR("Couldn't find frame capturer for this window %p", wnd);
+		return;
+	}
+
+	it->second->StartFrameCapture(wnd);
+}
+
+void RenderDoc::SetActiveWindow(void *wnd)
+{
+	auto it = m_WindowFrameCapturers.find(wnd);
+	if(it == m_WindowFrameCapturers.end())
+	{
+		RDCERR("Couldn't find frame capturer for this window %p", wnd);
+		return;
+	}
+
+	it->second->SetActiveWindow(wnd);
+}
+
+bool RenderDoc::EndFrameCapture(void *wnd)
+{
+	auto it = m_WindowFrameCapturers.find(wnd);
+	if(it == m_WindowFrameCapturers.end())
+	{
+		RDCERR("Couldn't find frame capturer for this window %p", wnd);
+		return false;
+	}
+
+	return it->second->EndFrameCapture(wnd);
+}
+
 void RenderDoc::Tick()
 {
 	static bool prev_f11 = false;

renderdoc/core/core.h

@@ -55,6 +55,13 @@ struct ICrashHandler
 	virtual void UnregisterMemoryRegion(void *mem) = 0;
 };
 
+struct IFrameCapturer
+{
+	virtual void StartFrameCapture(void *wnd) = 0;
+	virtual void SetActiveWindow(void *wnd) = 0;
+	virtual bool EndFrameCapture(void *wnd) = 0;
+};
+
 enum LogState
 {
 	READING = 0,
@@ -97,6 +104,18 @@ enum RDCDriver
 	RDC_Custom9,
 };
 
+enum InAppOverlay
+{
+	eOverlay_Enabled = 0x1,
+	eOverlay_FrameRate = 0x2,
+	eOverlay_FrameNumber = 0x4,
+	eOverlay_CaptureList = 0x8,
+
+	eOverlay_Default = (eOverlay_Enabled|eOverlay_FrameRate|eOverlay_FrameNumber|eOverlay_CaptureList),
+	eOverlay_All = ~0U,
+	eOverlay_None = 0,
+};
+
 namespace DXBC { class DXBCFile; }
 namespace Callstack { class StackResolver; }
 
@@ -201,9 +220,19 @@ class RenderDoc
 
 		void Tick();
 
+		void AddFrameCapturer(void *wnd, IFrameCapturer *cap) { if(wnd != NULL && cap != NULL) m_WindowFrameCapturers[wnd] = cap; }
+		void RemoveFrameCapturer(void *wnd) { m_WindowFrameCapturers.erase(wnd); }
+		
+		void StartFrameCapture(void *wnd);
+		void SetActiveWindow(void *wnd);
+		bool EndFrameCapture(void *wnd);
+
 		void FocusToggle() { m_Focus = true; m_Cap = false; }
 		void TriggerCapture() { m_Cap = true; }
 
+		uint32_t GetOverlayBits() { return m_Overlay; }
+		void MaskOverlayBits(uint32_t and, uint32_t or) { m_Overlay = (m_Overlay & and) | or; }
+
 		void QueueCapture(uint32_t frameNumber) { m_QueuedFrameCaptures.insert(frameNumber); }
 
 		bool ShouldFocusToggle() { bool ret = m_Focus; m_Focus = false; return ret; }
@@ -223,6 +252,7 @@ class RenderDoc
 		wstring m_LogFile;
 		wstring m_CurrentLogFile;
 		CaptureOptions m_Options;
+		uint32_t m_Overlay;
 
 		set<uint32_t> m_QueuedFrameCaptures;
 
@@ -243,6 +273,8 @@ class RenderDoc
 		map<RDCDriver, ReplayDriverProvider> m_ReplayDriverProviders;
 		map<RDCDriver, RemoteDriverProvider> m_RemoteDriverProviders;
 
+		map<void*, IFrameCapturer*> m_WindowFrameCapturers;
+
 		volatile bool m_RemoteServerThreadShutdown;
 		volatile bool m_RemoteClientThreadShutdown;
 		Threading::CriticalSection m_SingleClientLock;

renderdoc/driver/d3d11/d3d11_device.h

@@ -129,6 +129,7 @@ class WrappedID3D11ClassLinkage;
 enum CaptureFailReason;
 
 class WrappedID3D11Device :
+	public IFrameCapturer,
 #if defined(INCLUDE_D3D_11_1)
 	public ID3D11Device1
 #else
@@ -177,6 +178,7 @@ private:
 	Serialiser *m_pSerialiser;
 	Serialiser *m_pDebugSerialiser;
 	LogState m_State;
+	bool m_AppControlledCapture;
 	
 	set<ID3D11DeviceChild *> m_CachedStateObjects;
 	set<WrappedID3D11DeviceContext *> m_DeferredContexts;
@@ -245,6 +247,10 @@ public:
 	
 	void Serialise_CaptureScope(uint64_t offset);
 
+	void StartFrameCapture(void *wnd);
+	void SetActiveWindow(void *wnd);
+	bool EndFrameCapture(void *wnd);
+
 	////////////////////////////////////////////////////////////////
 	// log replaying
 	

renderdoc/driver/dxgi/dxgi_wrapped.cpp

@@ -146,12 +146,18 @@ WrappedIDXGISwapChain::WrappedIDXGISwapChain(IDXGISwapChain* real, WrappedID3D11
 
 	m_bFullscreen = desc.Windowed == FALSE;
 
+	RenderDoc::Inst().AddFrameCapturer(desc.OutputWindow, m_pDevice);
+
 	SAFE_ADDREF(m_pDevice);
 }
 
 WrappedIDXGISwapChain::~WrappedIDXGISwapChain()
 {
 	m_pDevice->ReleaseSwapchainResources(this);
+	
+	DXGI_SWAP_CHAIN_DESC desc;
+	m_pReal->GetDesc(&desc);
+	RenderDoc::Inst().RemoveFrameCapturer(desc.OutputWindow);
 
 	SAFE_RELEASE(m_pReal);
 	for(int i=0; i < MAX_NUM_BACKBUFFERS; i++)

renderdoc/replay/entry_points.cpp

@@ -194,12 +194,42 @@ uint32_t RENDERDOC_CC RENDERDOC_InjectIntoProcess(uint32_t pid, const wchar_t *l
 	return Process::InjectIntoProcess(pid, logfile, opts, waitForExit);
 }
 
+extern "C" RENDERDOC_API
+void RENDERDOC_CC RENDERDOC_SetActiveWindow(void *wndHandle)
+{
+	RenderDoc::Inst().SetActiveWindow(wndHandle);
+}
+
 extern "C" RENDERDOC_API
 void RENDERDOC_CC RENDERDOC_TriggerCapture()
 {
 	RenderDoc::Inst().TriggerCapture();
 }
 
+extern "C" RENDERDOC_API
+void RENDERDOC_CC RENDERDOC_StartFrameCapture(void *wndHandle)
+{
+	RenderDoc::Inst().StartFrameCapture(wndHandle);
+}
+
+extern "C" RENDERDOC_API
+bool RENDERDOC_CC RENDERDOC_EndFrameCapture(void *wndHandle)
+{
+	return RenderDoc::Inst().EndFrameCapture(wndHandle);
+}
+
+extern "C" RENDERDOC_API
+uint32_t RENDERDOC_CC RENDERDOC_GetOverlayBits()
+{
+	return RenderDoc::Inst().GetOverlayBits();
+}
+
+extern "C" RENDERDOC_API
+void RENDERDOC_CC RENDERDOC_MaskOverlayBits(uint32_t and, uint32_t or)
+{
+	RenderDoc::Inst().MaskOverlayBits(and, or);
+}
+
 extern "C" RENDERDOC_API
 void RENDERDOC_CC RENDERDOC_QueueCapture(uint32_t frameNumber)
 {

renderdoc/replay/renderdoc.h

@@ -224,9 +224,24 @@ typedef uint32_t (RENDERDOC_CC *pRENDERDOC_ExecuteAndInject)(const wchar_t *app,
 extern "C" RENDERDOC_API uint32_t RENDERDOC_CC RENDERDOC_InjectIntoProcess(uint32_t pid, const wchar_t *logfile, const CaptureOptions *opts, bool waitForExit);
 typedef uint32_t (RENDERDOC_CC *pRENDERDOC_InjectIntoProcess)(uint32_t pid, const wchar_t *logfile, const CaptureOptions *opts, bool waitForExit);
 
+extern "C" RENDERDOC_API void RENDERDOC_CC RENDERDOC_SetActiveWindow(void *wndHandle);
+typedef void (RENDERDOC_CC *pRENDERDOC_SetActiveWindow)(void *wndHandle);
+
 extern "C" RENDERDOC_API void RENDERDOC_CC RENDERDOC_TriggerCapture();
 typedef void (RENDERDOC_CC *pRENDERDOC_TriggerCapture)();
 
+extern "C" RENDERDOC_API void RENDERDOC_CC RENDERDOC_StartFrameCapture(void *wndHandle);
+typedef void (RENDERDOC_CC *pRENDERDOC_StartFrameCapture)(void *wndHandle);
+
+extern "C" RENDERDOC_API bool RENDERDOC_CC RENDERDOC_EndFrameCapture(void *wndHandle);
+typedef bool (RENDERDOC_CC *pRENDERDOC_EndFrameCapture)(void *wndHandle);
+
+extern "C" RENDERDOC_API uint32_t RENDERDOC_CC RENDERDOC_GetOverlayBits();
+typedef uint32_t (RENDERDOC_CC *pRENDERDOC_GetOverlayBits)();
+
+extern "C" RENDERDOC_API void RENDERDOC_CC RENDERDOC_MaskOverlayBits(uint32_t and, uint32_t or);
+typedef void (RENDERDOC_CC *pRENDERDOC_MaskOverlayBits)(uint32_t and, uint32_t or);
+
 //////////////////////////////////////////////////////////////////////////
 // Remote access and control
 //////////////////////////////////////////////////////////////////////////