diff --git a/renderdoc/driver/d3d12/d3d12_counters.cpp b/renderdoc/driver/d3d12/d3d12_counters.cpp
index 46bbea353..6e383fa1e 100644
--- a/renderdoc/driver/d3d12/d3d12_counters.cpp
+++ b/renderdoc/driver/d3d12/d3d12_counters.cpp
@@ -75,14 +75,14 @@ void D3D12Replay::DescribeCounter(uint32_t counterID, CounterDescription &desc)
   }
 }
 
-struct GPUTimerCallback : public D3D12DrawcallCallback
+struct D3D12GPUTimerCallback : public D3D12DrawcallCallback
 {
-  GPUTimerCallback(WrappedID3D12Device *dev, D3D12Replay *rp, ID3D12QueryHeap *qh)
+  D3D12GPUTimerCallback(WrappedID3D12Device *dev, D3D12Replay *rp, ID3D12QueryHeap *qh)
       : m_pDevice(dev), m_pReplay(rp), m_QueryHeap(qh)
   {
     m_pDevice->GetQueue()->GetCommandData()->m_DrawcallCallback = this;
   }
-  ~GPUTimerCallback() { m_pDevice->GetQueue()->GetCommandData()->m_DrawcallCallback = NULL; }
+  ~D3D12GPUTimerCallback() { m_pDevice->GetQueue()->GetCommandData()->m_DrawcallCallback = NULL; }
   void PreDraw(uint32_t eid, ID3D12GraphicsCommandList *cmd)
   {
     cmd->EndQuery(m_QueryHeap, D3D12_QUERY_TYPE_TIMESTAMP, (uint32_t)(m_Results.size() * 2 + 0));
@@ -167,7 +167,7 @@ vector<CounterResult> D3D12Replay::FetchCounters(const vector<uint32_t> &counter
 
   m_pDevice->SetStablePowerState(TRUE);
 
-  GPUTimerCallback cb(m_pDevice, this, queryHeap);
+  D3D12GPUTimerCallback cb(m_pDevice, this, queryHeap);
 
   // replay the events to perform all the queries
   m_pDevice->ReplayLog(0, maxEID, eReplay_Full);
diff --git a/renderdoc/driver/d3d12/d3d12_debug.cpp b/renderdoc/driver/d3d12/d3d12_debug.cpp
index c58476e1d..4f1e61328 100644
--- a/renderdoc/driver/d3d12/d3d12_debug.cpp
+++ b/renderdoc/driver/d3d12/d3d12_debug.cpp
@@ -6513,14 +6513,18 @@ bool D3D12DebugManager::GetHistogram(ResourceId texid, uint32_t sliceFace, uint3
   return true;
 }
 
-struct QuadOverdrawCallback : public D3D12DrawcallCallback
+struct D3D12QuadOverdrawCallback : public D3D12DrawcallCallback
 {
-  QuadOverdrawCallback(WrappedID3D12Device *dev, const vector<uint32_t> &events, PortableHandle uav)
+  D3D12QuadOverdrawCallback(WrappedID3D12Device *dev, const vector<uint32_t> &events,
+                            PortableHandle uav)
       : m_pDevice(dev), m_pDebug(dev->GetDebugManager()), m_Events(events), m_UAV(uav)
   {
     m_pDevice->GetQueue()->GetCommandData()->m_DrawcallCallback = this;
   }
-  ~QuadOverdrawCallback() { m_pDevice->GetQueue()->GetCommandData()->m_DrawcallCallback = NULL; }
+  ~D3D12QuadOverdrawCallback()
+  {
+    m_pDevice->GetQueue()->GetCommandData()->m_DrawcallCallback = NULL;
+  }
   void PreDraw(uint32_t eid, ID3D12GraphicsCommandList *cmd)
   {
     if(std::find(m_Events.begin(), m_Events.end(), eid) == m_Events.end())
@@ -7622,7 +7626,8 @@ ResourceId D3D12DebugManager::RenderOverlay(ResourceId texid, FormatComponentTyp
       m_WrappedDevice->ReplayLog(0, events[0], eReplay_WithoutDraw);
 
       // declare callback struct here
-      QuadOverdrawCallback cb(m_WrappedDevice, events, ToPortableHandle(GetCPUHandle(OVERDRAW_UAV)));
+      D3D12QuadOverdrawCallback cb(m_WrappedDevice, events,
+                                   ToPortableHandle(GetCPUHandle(OVERDRAW_UAV)));
 
       m_WrappedDevice->ReplayLog(events.front(), events.back(), eReplay_Full);
 
diff --git a/renderdoc/driver/d3d12/d3d12_replay.cpp b/renderdoc/driver/d3d12/d3d12_replay.cpp
index f067894cc..1365bc4f5 100644
--- a/renderdoc/driver/d3d12/d3d12_replay.cpp
+++ b/renderdoc/driver/d3d12/d3d12_replay.cpp
@@ -1418,14 +1418,14 @@ void D3D12Replay::InitPostVSBuffers(uint32_t eventID)
   m_pDevice->GetDebugManager()->InitPostVSBuffers(eventID);
 }
 
-struct InitPostVSCallback : public D3D12DrawcallCallback
+struct D3D12InitPostVSCallback : public D3D12DrawcallCallback
 {
-  InitPostVSCallback(WrappedID3D12Device *dev, const vector<uint32_t> &events)
+  D3D12InitPostVSCallback(WrappedID3D12Device *dev, const vector<uint32_t> &events)
       : m_pDevice(dev), m_Events(events)
   {
     m_pDevice->GetQueue()->GetCommandData()->m_DrawcallCallback = this;
   }
-  ~InitPostVSCallback() { m_pDevice->GetQueue()->GetCommandData()->m_DrawcallCallback = NULL; }
+  ~D3D12InitPostVSCallback() { m_pDevice->GetQueue()->GetCommandData()->m_DrawcallCallback = NULL; }
   void PreDraw(uint32_t eid, ID3D12GraphicsCommandList *cmd)
   {
     if(std::find(m_Events.begin(), m_Events.end(), eid) != m_Events.end())
@@ -1456,7 +1456,7 @@ void D3D12Replay::InitPostVSBuffers(const vector<uint32_t> &events)
   // command buffer
   m_pDevice->ReplayLog(0, events.front(), eReplay_WithoutDraw);
 
-  InitPostVSCallback cb(m_pDevice, events);
+  D3D12InitPostVSCallback cb(m_pDevice, events);
 
   // now we replay the events, which are guaranteed (because we generated them in
   // GetPassEvents above) to come from the same command buffer, so the event IDs are
diff --git a/renderdoc/driver/vulkan/vk_counters.cpp b/renderdoc/driver/vulkan/vk_counters.cpp
index 40ea083d0..b667db616 100644
--- a/renderdoc/driver/vulkan/vk_counters.cpp
+++ b/renderdoc/driver/vulkan/vk_counters.cpp
@@ -74,14 +74,14 @@ void VulkanReplay::DescribeCounter(uint32_t counterID, CounterDescription &desc)
     desc.units = eUnits_Absolute;
   }
 }
-struct GPUTimerCallback : public VulkanDrawcallCallback
+struct VulkanGPUTimerCallback : public VulkanDrawcallCallback
 {
-  GPUTimerCallback(WrappedVulkan *vk, VulkanReplay *rp, VkQueryPool qp)
+  VulkanGPUTimerCallback(WrappedVulkan *vk, VulkanReplay *rp, VkQueryPool qp)
       : m_pDriver(vk), m_pReplay(rp), m_QueryPool(qp)
   {
     m_pDriver->SetDrawcallCB(this);
   }
-  ~GPUTimerCallback() { m_pDriver->SetDrawcallCB(NULL); }
+  ~VulkanGPUTimerCallback() { m_pDriver->SetDrawcallCB(NULL); }
   void PreDraw(uint32_t eid, VkCommandBuffer cmd)
   {
     ObjDisp(cmd)->CmdWriteTimestamp(Unwrap(cmd), VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, m_QueryPool,
@@ -148,7 +148,7 @@ vector<CounterResult> VulkanReplay::FetchCounters(const vector<uint32_t> &counte
   m_pDriver->SubmitCmds();
 #endif
 
-  GPUTimerCallback cb(m_pDriver, this, pool);
+  VulkanGPUTimerCallback cb(m_pDriver, this, pool);
 
   // replay the events to perform all the queries
   m_pDriver->ReplayLog(0, maxEID, eReplay_Full);
diff --git a/renderdoc/driver/vulkan/vk_debug.cpp b/renderdoc/driver/vulkan/vk_debug.cpp
index 10ea4d061..ace2ceec3 100644
--- a/renderdoc/driver/vulkan/vk_debug.cpp
+++ b/renderdoc/driver/vulkan/vk_debug.cpp
@@ -4742,14 +4742,14 @@ void VulkanDebugManager::PatchFixedColShader(VkShaderModule &mod, float col[4])
   RDCASSERTEQUAL(vkr, VK_SUCCESS);
 }
 
-struct QuadOverdrawCallback : public VulkanDrawcallCallback
+struct VulkanQuadOverdrawCallback : public VulkanDrawcallCallback
 {
-  QuadOverdrawCallback(WrappedVulkan *vk, const vector<uint32_t> &events)
+  VulkanQuadOverdrawCallback(WrappedVulkan *vk, const vector<uint32_t> &events)
       : m_pDriver(vk), m_pDebug(vk->GetDebugManager()), m_Events(events), m_PrevState(NULL)
   {
     m_pDriver->SetDrawcallCB(this);
   }
-  ~QuadOverdrawCallback() { m_pDriver->SetDrawcallCB(NULL); }
+  ~VulkanQuadOverdrawCallback() { m_pDriver->SetDrawcallCB(NULL); }
   void PreDraw(uint32_t eid, VkCommandBuffer cmd)
   {
     if(std::find(m_Events.begin(), m_Events.end(), eid) == m_Events.end())
@@ -6211,7 +6211,7 @@ ResourceId VulkanDebugManager::RenderOverlay(ResourceId texid, TextureDisplayOve
       m_pDriver->ReplayLog(0, events[0], eReplay_WithoutDraw);
 
       // declare callback struct here
-      QuadOverdrawCallback cb(m_pDriver, events);
+      VulkanQuadOverdrawCallback cb(m_pDriver, events);
 
       m_pDriver->ReplayLog(events.front(), events.back(), eReplay_Full);
 
diff --git a/renderdoc/driver/vulkan/vk_replay.cpp b/renderdoc/driver/vulkan/vk_replay.cpp
index d37e29170..f1a2fde98 100644
--- a/renderdoc/driver/vulkan/vk_replay.cpp
+++ b/renderdoc/driver/vulkan/vk_replay.cpp
@@ -4531,14 +4531,14 @@ void VulkanReplay::InitPostVSBuffers(uint32_t eventID)
   GetDebugManager()->InitPostVSBuffers(eventID);
 }
 
-struct InitPostVSCallback : public VulkanDrawcallCallback
+struct VulkanInitPostVSCallback : public VulkanDrawcallCallback
 {
-  InitPostVSCallback(WrappedVulkan *vk, const vector<uint32_t> &events)
+  VulkanInitPostVSCallback(WrappedVulkan *vk, const vector<uint32_t> &events)
       : m_pDriver(vk), m_Events(events)
   {
     m_pDriver->SetDrawcallCB(this);
   }
-  ~InitPostVSCallback() { m_pDriver->SetDrawcallCB(NULL); }
+  ~VulkanInitPostVSCallback() { m_pDriver->SetDrawcallCB(NULL); }
   void PreDraw(uint32_t eid, VkCommandBuffer cmd)
   {
     if(std::find(m_Events.begin(), m_Events.end(), eid) != m_Events.end())
@@ -4569,7 +4569,7 @@ void VulkanReplay::InitPostVSBuffers(const vector<uint32_t> &events)
   // command buffer
   m_pDriver->ReplayLog(0, events.front(), eReplay_WithoutDraw);
 
-  InitPostVSCallback cb(m_pDriver, events);
+  VulkanInitPostVSCallback cb(m_pDriver, events);
 
   // now we replay the events, which are guaranteed (because we generated them in
   // GetPassEvents above) to come from the same command buffer, so the event IDs are