Remove 'using std::set'

renderdoc/core/core.cpp

@@ -746,7 +746,7 @@ bool RenderDoc::ShouldTriggerCapture(uint32_t frameNumber)
   if(m_Cap > 0)
     m_Cap--;
 
-  set<uint32_t> frames;
+  std::set<uint32_t> frames;
   frames.swap(m_QueuedFrameCaptures);
   for(auto it = frames.begin(); it != frames.end(); ++it)
   {

renderdoc/core/core.h

@@ -40,7 +40,6 @@
 
 using std::vector;
 using std::pair;
-using std::set;
 
 class Chunk;
 struct RDCThumb;
@@ -604,7 +603,7 @@ private:
   CaptureOptions m_Options;
   uint32_t m_Overlay;
 
-  set<uint32_t> m_QueuedFrameCaptures;
+  std::set<uint32_t> m_QueuedFrameCaptures;
 
   uint32_t m_RemoteIdent;
   Threading::ThreadHandle m_RemoteThread;
@@ -635,7 +634,7 @@ private:
   VulkanLayerCheck m_VulkanCheck;
   VulkanLayerInstall m_VulkanInstall;
 
-  set<ShutdownFunction> m_ShutdownFunctions;
+  std::set<ShutdownFunction> m_ShutdownFunctions;
 
   struct FrameCap
   {

renderdoc/core/replay_proxy.h

@@ -594,8 +594,8 @@ private:
   // this cache only exists on the client side, with the proxy renderer. This denotes cases where we
   // already have up-to-date texture data for the current event so we don't need to check for any
   // deltas. It is cleared any time we set event.
-  set<TextureCacheEntry> m_TextureProxyCache;
-  set<ResourceId> m_BufferProxyCache;
+  std::set<TextureCacheEntry> m_TextureProxyCache;
+  std::set<ResourceId> m_BufferProxyCache;
 
   struct ProxyTextureProperties
   {

renderdoc/core/resource_manager.h

@@ -33,8 +33,6 @@
 #include "os/os_specific.h"
 #include "serialise/serialiser.h"
 
-using std::set;
-
 // In what way (read, write, etc) was a resource referenced in a frame -
 // used to determine if initial contents are needed and to what degree.
 // These values are used both as states (representing the cumulative previous
@@ -591,7 +589,7 @@ protected:
   std::map<ResourceId, FrameRefType> m_FrameReferencedResources;
 
   // used during capture - holds resources marked as dirty, needing initial contents
-  set<ResourceId> m_DirtyResources;
+  std::set<ResourceId> m_DirtyResources;
 
   struct InitialContentDataOrChunk
   {
@@ -842,7 +840,7 @@ void ResourceManager<Configuration>::CreateInitialContents(ReadSerialiser &ser)
 {
   using namespace ResourceManagerInternal;
 
-  set<ResourceId> neededInitials;
+  std::set<ResourceId> neededInitials;
 
   std::vector<WrittenRecord> WrittenRecords;
   SERIALISE_ELEMENT(WrittenRecords);

renderdoc/driver/d3d11/d3d11_context.h

@@ -120,10 +120,10 @@ private:
     }
   };
 
-  set<ResourceId> m_DeferredDirty;
-  set<ResourceId> m_DeferredReferences;
+  std::set<ResourceId> m_DeferredDirty;
+  std::set<ResourceId> m_DeferredReferences;
 
-  set<ResourceId> m_HighTrafficResources;
+  std::set<ResourceId> m_HighTrafficResources;
   std::map<MappedResource, MapIntercept> m_OpenMaps;
 
   struct StreamOutData

renderdoc/driver/d3d11/d3d11_device.h

@@ -348,7 +348,7 @@ private:
 
   ReplayStatus m_FailedReplayStatus = ReplayStatus::APIReplayFailed;
 
-  set<ID3D11DeviceChild *> m_CachedStateObjects;
+  std::set<ID3D11DeviceChild *> m_CachedStateObjects;
 
   // This function will check if m_CachedStateObjects is growing too large, and if so
   // go through m_CachedStateObjects and release any state objects that are purely
@@ -365,7 +365,7 @@ private:
   // Must be called while m_D3DLock is held.
   void CachedObjectsGarbageCollect();
 
-  set<WrappedID3D11DeviceContext *> m_DeferredContexts;
+  std::set<WrappedID3D11DeviceContext *> m_DeferredContexts;
   std::map<ID3D11InputLayout *, vector<D3D11_INPUT_ELEMENT_DESC> > m_LayoutDescs;
   std::map<ID3D11InputLayout *, WrappedShader *> m_LayoutShaders;
 

renderdoc/driver/d3d11/d3d11_resources.h

@@ -1265,8 +1265,8 @@ class WrappedID3D11CommandList : public WrappedDeviceChild11<ID3D11CommandList>
   bool m_Successful;    // indicates whether we have all of the commands serialised for this command
                         // list
 
-  set<ResourceId> m_Dirty;
-  set<ResourceId> m_References;
+  std::set<ResourceId> m_Dirty;
+  std::set<ResourceId> m_References;
 
 public:
   ALLOCATE_WITH_WRAPPED_POOL(WrappedID3D11CommandList);
@@ -1294,14 +1294,14 @@ public:
 
   WrappedID3D11DeviceContext *GetContext() { return m_pContext; }
   bool IsCaptured() { return m_Successful; }
-  void SwapReferences(set<ResourceId> &refs) { m_References.swap(refs); }
-  void SwapDirtyResources(set<ResourceId> &dirty) { m_Dirty.swap(dirty); }
+  void SwapReferences(std::set<ResourceId> &refs) { m_References.swap(refs); }
+  void SwapDirtyResources(std::set<ResourceId> &dirty) { m_Dirty.swap(dirty); }
   void MarkDirtyResources(D3D11ResourceManager *manager)
   {
     for(auto it = m_Dirty.begin(); it != m_Dirty.end(); ++it)
       manager->MarkDirtyResource(*it);
   }
-  void MarkDirtyResources(set<ResourceId> &missingTracks)
+  void MarkDirtyResources(std::set<ResourceId> &missingTracks)
   {
     for(auto it = m_Dirty.begin(); it != m_Dirty.end(); ++it)
       missingTracks.insert(*it);

renderdoc/driver/d3d11/d3d11_shaderdebug.cpp

@@ -774,7 +774,7 @@ ShaderDebugTrace D3D11Replay::DebugVertex(uint32_t eventId, uint32_t vertid, uin
 
   vector<D3D11_INPUT_ELEMENT_DESC> inputlayout = m_pDevice->GetLayoutDesc(rs->IA.Layout);
 
-  set<UINT> vertexbuffers;
+  std::set<UINT> vertexbuffers;
   uint32_t trackingOffs[32] = {0};
 
   UINT MaxStepRate = 1U;

renderdoc/driver/d3d12/d3d12_counters.cpp

@@ -262,7 +262,7 @@ struct D3D12AMDDrawCallback : public D3D12DrawcallCallback
   WrappedID3D12Device *m_pDevice;
   D3D12Replay *m_pReplay;
   vector<uint32_t> *m_pEventIds;
-  set<ID3D12GraphicsCommandList *> m_begunCommandLists;
+  std::set<ID3D12GraphicsCommandList *> m_begunCommandLists;
 
   // events which are the 'same' from being the same command buffer resubmitted
   // multiple times in the frame. We will only get the full callback when we're

renderdoc/driver/d3d12/d3d12_device.h

@@ -321,7 +321,7 @@ private:
   D3D12ShaderCache *m_ShaderCache = NULL;
   D3D12TextRenderer *m_TextRenderer = NULL;
 
-  set<ResourceId> m_UploadResourceIds;
+  std::set<ResourceId> m_UploadResourceIds;
   std::map<uint64_t, ID3D12Resource *> m_UploadBuffers;
 
   Threading::CriticalSection m_MapsLock;
@@ -394,7 +394,7 @@ private:
   std::map<ResourceId, SubresourceStateVector> m_ResourceStates;
   Threading::CriticalSection m_ResourceStatesLock;
 
-  set<ResourceId> m_Cubemaps;
+  std::set<ResourceId> m_Cubemaps;
 
   std::map<ResourceId, std::string> m_ResourceNames;
 

renderdoc/driver/d3d12/d3d12_manager.h

@@ -423,7 +423,7 @@ struct CmdListRecordingInfo
   vector<D3D12_RESOURCE_BARRIER> barriers;
 
   // a list of all resources dirtied by this command list
-  set<ResourceId> dirtied;
+  std::set<ResourceId> dirtied;
 
   // a list of descriptors that are bound at any point in this command list
   // used to look up all the frame refs per-descriptor and apply them on queue

renderdoc/driver/gl/gl_driver.h

@@ -184,7 +184,7 @@ private:
   CaptureFailReason m_FailureReason;
   bool m_SuccessfulCapture;
 
-  set<ResourceId> m_HighTrafficResources;
+  std::set<ResourceId> m_HighTrafficResources;
 
   int m_ReplayEventCount = 0;
 
@@ -192,12 +192,12 @@ private:
   // we need to flush both types of maps, but for implicit sync points we only
   // want to consider coherent maps, and since that happens often we want it to
   // be as efficient as possible.
-  set<GLResourceRecord *> m_CoherentMaps;
-  set<GLResourceRecord *> m_PersistentMaps;
+  std::set<GLResourceRecord *> m_CoherentMaps;
+  std::set<GLResourceRecord *> m_PersistentMaps;
 
   // this function iterates over all the maps, checking for any changes between
   // the shadow pointers, and propogates that to 'real' GL
-  void PersistentMapMemoryBarrier(const set<GLResourceRecord *> &maps);
+  void PersistentMapMemoryBarrier(const std::set<GLResourceRecord *> &maps);
 
   // this function is called at any point that could possibly pick up a change
   // in a coherent persistent mapped buffer, to propogate changes across. In most

renderdoc/driver/gl/gl_resources.h

@@ -261,7 +261,7 @@ struct GLResourceRecord : public ResourceRecord
   // for anything that is viewed if the viewer is frame referenced. Otherwise we might
   // lose the underlying data for the view.
   // Since it's 1-to-many, we keep a set here.
-  set<ResourceId> viewTextures;
+  std::set<ResourceId> viewTextures;
 
   GLResource Resource;
 

renderdoc/driver/gl/wrappers/gl_buffer_funcs.cpp

@@ -2650,14 +2650,14 @@ void WrappedOpenGL::glFlushMappedBufferRange(GLenum target, GLintptr offset, GLs
   return GL.glFlushMappedBufferRange(target, offset, length);
 }
 
-void WrappedOpenGL::PersistentMapMemoryBarrier(const set<GLResourceRecord *> &maps)
+void WrappedOpenGL::PersistentMapMemoryBarrier(const std::set<GLResourceRecord *> &maps)
 {
   PUSH_CURRENT_CHUNK;
 
   // this function iterates over all the maps, checking for any changes between
   // the shadow pointers, and propogates that to 'real' GL
 
-  for(set<GLResourceRecord *>::const_iterator it = maps.begin(); it != maps.end(); ++it)
+  for(std::set<GLResourceRecord *>::const_iterator it = maps.begin(); it != maps.end(); ++it)
   {
     GLResourceRecord *record = *it;
 

renderdoc/driver/vulkan/vk_counters.cpp

@@ -272,7 +272,7 @@ struct VulkanAMDDrawCallback : public VulkanDrawcallCallback
   WrappedVulkan *m_pDriver;
   VulkanReplay *m_pReplay;
   vector<uint32_t> *m_pEventIds;
-  set<VkCommandBuffer> m_begunCommandBuffers;
+  std::set<VkCommandBuffer> m_begunCommandBuffers;
   // events which are the 'same' from being the same command buffer resubmitted
   // multiple times in the frame. We will only get the full callback when we're
   // recording the command buffer, and will be given the first EID. After that

renderdoc/driver/vulkan/vk_resources.h

@@ -921,15 +921,15 @@ struct CmdBufferRecordingInfo
 
   // sparse resources referenced by this command buffer (at submit time
   // need to go through the sparse mapping and reference all memory)
-  set<ResourceInfo *> sparse;
+  std::set<ResourceInfo *> sparse;
 
   // a list of all resources dirtied by this command buffer
-  set<ResourceId> dirtied;
+  std::set<ResourceId> dirtied;
 
   // a list of descriptor sets that are bound at any point in this command buffer
   // used to look up all the frame refs per-desc set and apply them on queue
   // submit with latest binding refs.
-  set<VkDescriptorSet> boundDescSets;
+  std::set<VkDescriptorSet> boundDescSets;
 
   vector<VkResourceRecord *> subcmds;
 

renderdoc/driver/vulkan/wrappers/vk_queue_funcs.cpp

@@ -786,7 +786,7 @@ VkResult WrappedVulkan::vkQueueSubmit(VkQueue queue, uint32_t submitCount,
     capframe = IsActiveCapturing(m_State);
   }
 
-  set<ResourceId> refdIDs;
+  std::set<ResourceId> refdIDs;
 
   VkResourceRecord *queueRecord = GetRecord(queue);
 

renderdoc/os/win32/win32_stringio.cpp

@@ -35,8 +35,6 @@
 #include "os/os_specific.h"
 #include "strings/string_utils.h"
 
-using std::set;
-
 // gives us an address to identify this dll with
 static int dllLocator = 0;
 
@@ -79,7 +77,7 @@ bool PlatformHasKeyInput()
   return true;
 }
 
-set<HWND> inputWindows;
+std::set<HWND> inputWindows;
 
 void AddInputWindow(void *wnd)
 {