Put 'real' handle into tiny struct similar to one in vulkan.h

* This lets us have a more type-safe 'generic vulkan handle' struct, and
  we can give that to the resource manager when specifying what type
  we're wrapping.

renderdoc/core/resource_manager.cpp

@@ -45,7 +45,7 @@ namespace ResourceIDGen
 
 void ResourceRecord::MarkResourceFrameReferenced(ResourceId id, FrameRefType refType)
 {
-	ResourceManager<void*,ResourceRecord>::MarkReferenced(m_FrameRefs, id, refType);
+	ResourceManager<void*,void*,ResourceRecord>::MarkReferenced(m_FrameRefs, id, refType);
 }
 
 void ResourceRecord::AddResourceReferences(ResourceRecordHandler *mgr)

renderdoc/core/resource_manager.h

@@ -298,7 +298,7 @@ protected:
 // 
 // In the replay application it will also track which 'live' resources are representing which 'original'
 // resources from the application when it was captured.
-template<typename ResourceType, typename RecordType>
+template<typename WrappedResourceType, typename RealResourceType, typename RecordType>
 class ResourceManager : public ResourceRecordHandler
 {
 	public:
@@ -309,9 +309,9 @@ class ResourceManager : public ResourceRecordHandler
 
 		struct InitialContentData
 		{
-			InitialContentData(ResourceType r, uint32_t n, byte *b) : resource(r), num(n), blob(b) {}
-			InitialContentData() : resource((ResourceType)RecordType::NullResource), num(0), blob(NULL) {}
-			ResourceType resource;
+			InitialContentData(WrappedResourceType r, uint32_t n, byte *b) : resource(r), num(n), blob(b) {}
+			InitialContentData() : resource((WrappedResourceType)RecordType::NullResource), num(0), blob(NULL) {}
+			WrappedResourceType resource;
 			uint32_t num;
 			byte *blob;
 		};
@@ -326,9 +326,9 @@ class ResourceManager : public ResourceRecordHandler
 		inline void RemoveResourceRecord(ResourceId id);
 		
 		// while capturing or replaying, resources and their live IDs
-		void AddCurrentResource(ResourceId id, ResourceType res);
+		void AddCurrentResource(ResourceId id, WrappedResourceType res);
 		bool HasCurrentResource(ResourceId id);
-		ResourceType GetCurrentResource(ResourceId id);
+		WrappedResourceType GetCurrentResource(ResourceId id);
 		void ReleaseCurrentResource(ResourceId id);
 
 		void MarkInFrame(bool inFrame) { m_InFrame = inFrame; }
@@ -391,9 +391,9 @@ class ResourceManager : public ResourceRecordHandler
 		// Replay-side methods
 		
 		// Live resources to replace serialised IDs
-		void AddLiveResource(ResourceId origid, ResourceType livePtr);
+		void AddLiveResource(ResourceId origid, WrappedResourceType livePtr);
 		bool HasLiveResource(ResourceId origid);
-		ResourceType GetLiveResource(ResourceId origid);
+		WrappedResourceType GetLiveResource(ResourceId origid);
 		void EraseLiveResource(ResourceId origid);
 		
 		// when asked for a given id, return the resource for a replacement id
@@ -411,24 +411,24 @@ class ResourceManager : public ResourceRecordHandler
 		void ApplyInitialContents();
 
 		// Resource wrapping, allows for querying and adding/removing of wrapper layers around resources
-		bool AddWrapper(ResourceType wrap, ResourceType real);
-		bool HasWrapper(ResourceType real);
-		ResourceType GetWrapper(ResourceType real);
-		void RemoveWrapper(ResourceType real);
+		bool AddWrapper(WrappedResourceType wrap, RealResourceType real);
+		bool HasWrapper(RealResourceType real);
+		WrappedResourceType GetWrapper(RealResourceType real);
+		void RemoveWrapper(RealResourceType real);
 
 	protected:
 		// 'interface' to implement by derived classes
 		virtual bool SerialisableResource(ResourceId id, RecordType *record) = 0;
-		virtual ResourceId GetID(ResourceType res) = 0;
+		virtual ResourceId GetID(WrappedResourceType res) = 0;
 		
-		virtual bool ResourceTypeRelease(ResourceType res) = 0;
+		virtual bool ResourceTypeRelease(WrappedResourceType res) = 0;
 
-		virtual bool Force_InitialState(ResourceType res) = 0;
-		virtual bool Need_InitialStateChunk(ResourceType res) = 0;
-		virtual bool Prepare_InitialState(ResourceType res) = 0;
-		virtual bool Serialise_InitialState(ResourceType res) = 0;
-		virtual void Create_InitialState(ResourceId id, ResourceType live, bool hasData) = 0;
-		virtual void Apply_InitialState(ResourceType live, InitialContentData initial) = 0;
+		virtual bool Force_InitialState(WrappedResourceType res) = 0;
+		virtual bool Need_InitialStateChunk(WrappedResourceType res) = 0;
+		virtual bool Prepare_InitialState(WrappedResourceType res) = 0;
+		virtual bool Serialise_InitialState(WrappedResourceType res) = 0;
+		virtual void Create_InitialState(ResourceId id, WrappedResourceType live, bool hasData) = 0;
+		virtual void Apply_InitialState(WrappedResourceType live, InitialContentData initial) = 0;
 
 		LogState m_State;
 		Serialiser *m_pSerialiser;
@@ -445,7 +445,7 @@ class ResourceManager : public ResourceRecordHandler
 		// likely prove that some or all of these could be a problem
 		
 		// used during capture - map from real resource to its wrapper (other way can be done just with an Unwrap)
-		map<ResourceType, ResourceType> m_WrapperMap;
+		map<RealResourceType, WrappedResourceType> m_WrapperMap;
 
 		// used during capture - holds resources referenced in current frame (and how they're referenced)
 		map<ResourceId, FrameRefType> m_FrameReferencedResources;
@@ -461,14 +461,14 @@ class ResourceManager : public ResourceRecordHandler
 		map<ResourceId, Chunk*> m_InitialChunks;
 
 		// used during capture or replay - map of resources currently alive with their real IDs, used in capture and replay.
-		map<ResourceId, ResourceType> m_CurrentResourceMap;
+		map<ResourceId, WrappedResourceType> m_CurrentResourceMap;
 
 		// used during replay - maps back and forth from original id to live id and vice-versa
 		map<ResourceId, ResourceId> m_OriginalIDs, m_LiveIDs;
 		
 		// used during replay - holds resources allocated and the original id that they represent
 		// for a) in-frame creations and b) pre-frame creations respectively.
-		map<ResourceId, ResourceType> m_InframeResourceMap, m_LiveResourceMap;
+		map<ResourceId, WrappedResourceType> m_InframeResourceMap, m_LiveResourceMap;
 
 		// used during capture - holds resource records by id.
 		map<ResourceId, RecordType*> m_ResourceRecords;
@@ -477,8 +477,8 @@ class ResourceManager : public ResourceRecordHandler
 		map<ResourceId, ResourceId> m_Replacements;
 };
 
-template<typename ResourceType, typename RecordType>
-ResourceManager<ResourceType, RecordType>::ResourceManager(LogState state, Serialiser *ser)
+template<typename WrappedResourceType, typename RealResourceType, typename RecordType>
+ResourceManager<WrappedResourceType, RealResourceType, RecordType>::ResourceManager(LogState state, Serialiser *ser)
 {
 	if(RenderDoc::Inst().GetCrashHandler())
 		RenderDoc::Inst().GetCrashHandler()->RegisterMemoryRegion(this, sizeof(ResourceManager));
@@ -489,8 +489,8 @@ ResourceManager<ResourceType, RecordType>::ResourceManager(LogState state, Seria
 	m_InFrame = false;
 }
 
-template<typename ResourceType, typename RecordType>
-void ResourceManager<ResourceType, RecordType>::Shutdown()
+template<typename WrappedResourceType, typename RealResourceType, typename RecordType>
+void ResourceManager<WrappedResourceType, RealResourceType, RecordType>::Shutdown()
 {
 	while(!m_LiveResourceMap.empty())
 	{
@@ -520,8 +520,8 @@ void ResourceManager<ResourceType, RecordType>::Shutdown()
 	RDCASSERT(m_ResourceRecords.empty());
 }
 
-template<typename ResourceType, typename RecordType>
-ResourceManager<ResourceType, RecordType>::~ResourceManager()
+template<typename WrappedResourceType, typename RealResourceType, typename RecordType>
+ResourceManager<WrappedResourceType, RealResourceType, RecordType>::~ResourceManager()
 {
 	RDCASSERT(m_LiveResourceMap.empty());
 	RDCASSERT(m_InframeResourceMap.empty());
@@ -532,8 +532,8 @@ ResourceManager<ResourceType, RecordType>::~ResourceManager()
 		RenderDoc::Inst().GetCrashHandler()->UnregisterMemoryRegion(this);
 }
 
-template<typename ResourceType, typename RecordType>
-bool ResourceManager<ResourceType, RecordType>::MarkReferenced(map<ResourceId, FrameRefType> &refs, ResourceId id, FrameRefType refType)
+template<typename WrappedResourceType, typename RealResourceType, typename RecordType>
+bool ResourceManager<WrappedResourceType, RealResourceType, RecordType>::MarkReferenced(map<ResourceId, FrameRefType> &refs, ResourceId id, FrameRefType refType)
 {
 	if(refs.find(id) == refs.end())
 	{
@@ -576,8 +576,8 @@ bool ResourceManager<ResourceType, RecordType>::MarkReferenced(map<ResourceId, F
 	return false;
 }
 
-template<typename ResourceType, typename RecordType>
-void ResourceManager<ResourceType, RecordType>::MarkResourceFrameReferenced(ResourceId id, FrameRefType refType)
+template<typename WrappedResourceType, typename RealResourceType, typename RecordType>
+void ResourceManager<WrappedResourceType, RealResourceType, RecordType>::MarkResourceFrameReferenced(ResourceId id, FrameRefType refType)
 {
 	SCOPED_LOCK(m_Lock);
 
@@ -595,8 +595,8 @@ void ResourceManager<ResourceType, RecordType>::MarkResourceFrameReferenced(Reso
 	}
 }
 
-template<typename ResourceType, typename RecordType>
-bool ResourceManager<ResourceType, RecordType>::ReadBeforeWrite(ResourceId id)
+template<typename WrappedResourceType, typename RealResourceType, typename RecordType>
+bool ResourceManager<WrappedResourceType, RealResourceType, RecordType>::ReadBeforeWrite(ResourceId id)
 {
 	if(m_FrameReferencedResources.find(id) != m_FrameReferencedResources.end())
 		return m_FrameReferencedResources[id] == eFrameRef_ReadBeforeWrite ||
@@ -605,8 +605,8 @@ bool ResourceManager<ResourceType, RecordType>::ReadBeforeWrite(ResourceId id)
 	return false;
 }
 
-template<typename ResourceType, typename RecordType>
-void ResourceManager<ResourceType, RecordType>::MarkDirtyResource(ResourceId res)
+template<typename WrappedResourceType, typename RealResourceType, typename RecordType>
+void ResourceManager<WrappedResourceType, RealResourceType, RecordType>::MarkDirtyResource(ResourceId res)
 {
 	SCOPED_LOCK(m_Lock);
 
@@ -616,8 +616,8 @@ void ResourceManager<ResourceType, RecordType>::MarkDirtyResource(ResourceId res
 	m_DirtyResources.insert(res);
 }
 
-template<typename ResourceType, typename RecordType>
-void ResourceManager<ResourceType, RecordType>::MarkPendingDirty(ResourceId res)
+template<typename WrappedResourceType, typename RealResourceType, typename RecordType>
+void ResourceManager<WrappedResourceType, RealResourceType, RecordType>::MarkPendingDirty(ResourceId res)
 {
 	SCOPED_LOCK(m_Lock);
 
@@ -627,8 +627,8 @@ void ResourceManager<ResourceType, RecordType>::MarkPendingDirty(ResourceId res)
 	m_PendingDirtyResources.insert(res);
 }
 
-template<typename ResourceType, typename RecordType>
-void ResourceManager<ResourceType, RecordType>::FlushPendingDirty()
+template<typename WrappedResourceType, typename RealResourceType, typename RecordType>
+void ResourceManager<WrappedResourceType, RealResourceType, RecordType>::FlushPendingDirty()
 {
 	SCOPED_LOCK(m_Lock);
 
@@ -636,8 +636,8 @@ void ResourceManager<ResourceType, RecordType>::FlushPendingDirty()
 	m_PendingDirtyResources.clear();
 }
 
-template<typename ResourceType, typename RecordType>
-bool ResourceManager<ResourceType, RecordType>::IsResourceDirty(ResourceId res)
+template<typename WrappedResourceType, typename RealResourceType, typename RecordType>
+bool ResourceManager<WrappedResourceType, RealResourceType, RecordType>::IsResourceDirty(ResourceId res)
 {
 	SCOPED_LOCK(m_Lock);
 
@@ -647,8 +647,8 @@ bool ResourceManager<ResourceType, RecordType>::IsResourceDirty(ResourceId res)
 	return m_DirtyResources.find(res) != m_DirtyResources.end();
 }
 
-template<typename ResourceType, typename RecordType>
-void ResourceManager<ResourceType, RecordType>::MarkCleanResource(ResourceId res)
+template<typename WrappedResourceType, typename RealResourceType, typename RecordType>
+void ResourceManager<WrappedResourceType, RealResourceType, RecordType>::MarkCleanResource(ResourceId res)
 {
 	SCOPED_LOCK(m_Lock);
 	
@@ -661,8 +661,8 @@ void ResourceManager<ResourceType, RecordType>::MarkCleanResource(ResourceId res
 	}
 }
 
-template<typename ResourceType, typename RecordType>
-void ResourceManager<ResourceType, RecordType>::SetInitialContents(ResourceId id, InitialContentData contents)
+template<typename WrappedResourceType, typename RealResourceType, typename RecordType>
+void ResourceManager<WrappedResourceType, RealResourceType, RecordType>::SetInitialContents(ResourceId id, InitialContentData contents)
 {
 	SCOPED_LOCK(m_Lock);
 
@@ -680,8 +680,8 @@ void ResourceManager<ResourceType, RecordType>::SetInitialContents(ResourceId id
 	m_InitialContents[id] = contents;
 }
 
-template<typename ResourceType, typename RecordType>
-void ResourceManager<ResourceType, RecordType>::SetInitialChunk(ResourceId id, Chunk *chunk)
+template<typename WrappedResourceType, typename RealResourceType, typename RecordType>
+void ResourceManager<WrappedResourceType, RealResourceType, RecordType>::SetInitialChunk(ResourceId id, Chunk *chunk)
 {
 	SCOPED_LOCK(m_Lock);
 
@@ -701,8 +701,8 @@ void ResourceManager<ResourceType, RecordType>::SetInitialChunk(ResourceId id, C
 	m_InitialChunks[id] = chunk;
 }
 
-template<typename ResourceType, typename RecordType>
-typename ResourceManager<ResourceType, RecordType>::InitialContentData ResourceManager<ResourceType, RecordType>::GetInitialContents(ResourceId id)
+template<typename WrappedResourceType, typename RealResourceType, typename RecordType>
+typename ResourceManager<WrappedResourceType, RealResourceType, RecordType>::InitialContentData ResourceManager<WrappedResourceType, RealResourceType, RecordType>::GetInitialContents(ResourceId id)
 {
 	SCOPED_LOCK(m_Lock);
 
@@ -715,8 +715,8 @@ typename ResourceManager<ResourceType, RecordType>::InitialContentData ResourceM
 	return InitialContentData();
 }
 
-template<typename ResourceType, typename RecordType>
-void ResourceManager<ResourceType, RecordType>::Serialise_InitialContentsNeeded()
+template<typename WrappedResourceType, typename RealResourceType, typename RecordType>
+void ResourceManager<WrappedResourceType, RealResourceType, RecordType>::Serialise_InitialContentsNeeded()
 {
 	SCOPED_LOCK(m_Lock);
 
@@ -760,8 +760,8 @@ void ResourceManager<ResourceType, RecordType>::Serialise_InitialContentsNeeded(
 	}
 }
 
-template<typename ResourceType, typename RecordType>
-void ResourceManager<ResourceType, RecordType>::CreateInitialContents()
+template<typename WrappedResourceType, typename RealResourceType, typename RecordType>
+void ResourceManager<WrappedResourceType, RealResourceType, RecordType>::CreateInitialContents()
 {
 	set<ResourceId> neededInitials;
 
@@ -800,8 +800,8 @@ void ResourceManager<ResourceType, RecordType>::CreateInitialContents()
 	}
 }
 
-template<typename ResourceType, typename RecordType>
-void ResourceManager<ResourceType, RecordType>::ApplyInitialContents()
+template<typename WrappedResourceType, typename RealResourceType, typename RecordType>
+void ResourceManager<WrappedResourceType, RealResourceType, RecordType>::ApplyInitialContents()
 {
 	RDCDEBUG("Applying initial contents");
 	uint32_t numContents = 0;
@@ -811,7 +811,7 @@ void ResourceManager<ResourceType, RecordType>::ApplyInitialContents()
 		
 		if(HasLiveResource(id))
 		{
-			ResourceType live = GetLiveResource(id);
+			WrappedResourceType live = GetLiveResource(id);
 
 			numContents++;
 
@@ -821,8 +821,8 @@ void ResourceManager<ResourceType, RecordType>::ApplyInitialContents()
 	RDCDEBUG("Applied %d", numContents);
 }
 
-template<typename ResourceType, typename RecordType>
-void ResourceManager<ResourceType, RecordType>::MarkUnwrittenResources()
+template<typename WrappedResourceType, typename RealResourceType, typename RecordType>
+void ResourceManager<WrappedResourceType, RealResourceType, RecordType>::MarkUnwrittenResources()
 {
 	SCOPED_LOCK(m_Lock);
 	
@@ -832,8 +832,8 @@ void ResourceManager<ResourceType, RecordType>::MarkUnwrittenResources()
 	}
 }
 
-template<typename ResourceType, typename RecordType>
-void ResourceManager<ResourceType, RecordType>::InsertReferencedChunks(Serialiser *fileSer)
+template<typename WrappedResourceType, typename RealResourceType, typename RecordType>
+void ResourceManager<WrappedResourceType, RealResourceType, RecordType>::InsertReferencedChunks(Serialiser *fileSer)
 {
 	map<int32_t,Chunk*> sortedChunks;
 
@@ -871,8 +871,8 @@ void ResourceManager<ResourceType, RecordType>::InsertReferencedChunks(Serialise
 	RDCDEBUG("inserted to serialiser");
 }
 
-template<typename ResourceType, typename RecordType>
-void ResourceManager<ResourceType, RecordType>::PrepareInitialContents()
+template<typename WrappedResourceType, typename RealResourceType, typename RecordType>
+void ResourceManager<WrappedResourceType, RealResourceType, RecordType>::PrepareInitialContents()
 {
 	for(auto it=m_DirtyResources.begin(); it != m_DirtyResources.end(); ++it)
 	{
@@ -881,7 +881,7 @@ void ResourceManager<ResourceType, RecordType>::PrepareInitialContents()
 		if(!HasCurrentResource(id)) continue;
 
 		RecordType *record = GetResourceRecord(id);
-		ResourceType res = GetCurrentResource(id);
+		WrappedResourceType res = GetCurrentResource(id);
 
 		if(record == NULL || record->SpecialResource) continue;
 		
@@ -892,7 +892,7 @@ void ResourceManager<ResourceType, RecordType>::PrepareInitialContents()
 
 	for(auto it=m_CurrentResourceMap.begin(); it != m_CurrentResourceMap.end(); ++it)
 	{
-		if(it->second == (ResourceType)RecordType::NullResource) continue;
+		if(it->second == (WrappedResourceType)RecordType::NullResource) continue;
 
 		if(Force_InitialState(it->second))
 		{
@@ -901,8 +901,8 @@ void ResourceManager<ResourceType, RecordType>::PrepareInitialContents()
 	}
 }
 
-template<typename ResourceType, typename RecordType>
-void ResourceManager<ResourceType, RecordType>::InsertInitialContentsChunks(Serialiser *fileSerialiser)
+template<typename WrappedResourceType, typename RealResourceType, typename RecordType>
+void ResourceManager<WrappedResourceType, RealResourceType, RecordType>::InsertInitialContentsChunks(Serialiser *fileSerialiser)
 {
 	SCOPED_LOCK(m_Lock);
 
@@ -920,7 +920,7 @@ void ResourceManager<ResourceType, RecordType>::InsertInitialContentsChunks(Seri
 		if(!HasCurrentResource(id)) continue;
 
 		RecordType *record = GetResourceRecord(id);
-		ResourceType res = GetCurrentResource(id);
+		WrappedResourceType res = GetCurrentResource(id);
 
 		if(record == NULL || record->SpecialResource) continue;
 
@@ -951,7 +951,7 @@ void ResourceManager<ResourceType, RecordType>::InsertInitialContentsChunks(Seri
 
 	for(auto it=m_CurrentResourceMap.begin(); it != m_CurrentResourceMap.end(); ++it)
 	{
-		if(it->second == (ResourceType)RecordType::NullResource) continue;
+		if(it->second == (WrappedResourceType)RecordType::NullResource) continue;
 
 		if(Force_InitialState(it->second))
 		{
@@ -980,8 +980,8 @@ void ResourceManager<ResourceType, RecordType>::InsertInitialContentsChunks(Seri
 	m_InitialChunks.clear();
 }
 
-template<typename ResourceType, typename RecordType>
-void ResourceManager<ResourceType, RecordType>::ReleaseInFrameResources()
+template<typename WrappedResourceType, typename RealResourceType, typename RecordType>
+void ResourceManager<WrappedResourceType, RealResourceType, RecordType>::ReleaseInFrameResources()
 {	
 	SCOPED_LOCK(m_Lock);
 	
@@ -995,8 +995,8 @@ void ResourceManager<ResourceType, RecordType>::ReleaseInFrameResources()
 	m_InframeResourceMap.clear();
 }
 
-template<typename ResourceType, typename RecordType>
-void ResourceManager<ResourceType, RecordType>::ClearReferencedResources()
+template<typename WrappedResourceType, typename RealResourceType, typename RecordType>
+void ResourceManager<WrappedResourceType, RealResourceType, RecordType>::ClearReferencedResources()
 {	
 	SCOPED_LOCK(m_Lock);
 	
@@ -1011,8 +1011,8 @@ void ResourceManager<ResourceType, RecordType>::ClearReferencedResources()
 	m_FrameReferencedResources.clear();
 }
 
-template<typename ResourceType, typename RecordType>
-void ResourceManager<ResourceType, RecordType>::ReplaceResource(ResourceId from, ResourceId to)
+template<typename WrappedResourceType, typename RealResourceType, typename RecordType>
+void ResourceManager<WrappedResourceType, RealResourceType, RecordType>::ReplaceResource(ResourceId from, ResourceId to)
 {
 	SCOPED_LOCK(m_Lock);
 
@@ -1020,8 +1020,8 @@ void ResourceManager<ResourceType, RecordType>::ReplaceResource(ResourceId from,
 		m_Replacements[from] = to;
 }
 
-template<typename ResourceType, typename RecordType>
-void ResourceManager<ResourceType, RecordType>::RemoveReplacement(ResourceId id)
+template<typename WrappedResourceType, typename RealResourceType, typename RecordType>
+void ResourceManager<WrappedResourceType, RealResourceType, RecordType>::RemoveReplacement(ResourceId id)
 {
 	SCOPED_LOCK(m_Lock);
 	
@@ -1033,8 +1033,8 @@ void ResourceManager<ResourceType, RecordType>::RemoveReplacement(ResourceId id)
 	m_Replacements.erase(it);
 }
 
-template<typename ResourceType, typename RecordType>
-RecordType *ResourceManager<ResourceType, RecordType>::GetResourceRecord(ResourceId id)
+template<typename WrappedResourceType, typename RealResourceType, typename RecordType>
+RecordType *ResourceManager<WrappedResourceType, RealResourceType, RecordType>::GetResourceRecord(ResourceId id)
 {
 	SCOPED_LOCK(m_Lock);
 
@@ -1046,8 +1046,8 @@ RecordType *ResourceManager<ResourceType, RecordType>::GetResourceRecord(Resourc
 	return it->second;
 }
 
-template<typename ResourceType, typename RecordType>
-bool ResourceManager<ResourceType, RecordType>::HasResourceRecord(ResourceId id)
+template<typename WrappedResourceType, typename RealResourceType, typename RecordType>
+bool ResourceManager<WrappedResourceType, RealResourceType, RecordType>::HasResourceRecord(ResourceId id)
 {
 	SCOPED_LOCK(m_Lock);
 
@@ -1059,8 +1059,8 @@ bool ResourceManager<ResourceType, RecordType>::HasResourceRecord(ResourceId id)
 	return true;
 }
 
-template<typename ResourceType, typename RecordType>
-RecordType *ResourceManager<ResourceType, RecordType>::AddResourceRecord(ResourceId id)
+template<typename WrappedResourceType, typename RealResourceType, typename RecordType>
+RecordType *ResourceManager<WrappedResourceType, RealResourceType, RecordType>::AddResourceRecord(ResourceId id)
 {
 	SCOPED_LOCK(m_Lock);
 
@@ -1069,8 +1069,8 @@ RecordType *ResourceManager<ResourceType, RecordType>::AddResourceRecord(Resourc
 	return (m_ResourceRecords[id] = new RecordType(id));
 }
 
-template<typename ResourceType, typename RecordType>
-void ResourceManager<ResourceType, RecordType>::RemoveResourceRecord(ResourceId id)
+template<typename WrappedResourceType, typename RealResourceType, typename RecordType>
+void ResourceManager<WrappedResourceType, RealResourceType, RecordType>::RemoveResourceRecord(ResourceId id)
 {
 	SCOPED_LOCK(m_Lock);
 
@@ -1079,20 +1079,20 @@ void ResourceManager<ResourceType, RecordType>::RemoveResourceRecord(ResourceId
 	m_ResourceRecords.erase(id);
 }
 
-template<typename ResourceType, typename RecordType>
-bool ResourceManager<ResourceType, RecordType>::AddWrapper(ResourceType wrap, ResourceType real)
+template<typename WrappedResourceType, typename RealResourceType, typename RecordType>
+bool ResourceManager<WrappedResourceType, RealResourceType, RecordType>::AddWrapper(WrappedResourceType wrap, RealResourceType real)
 {
 	SCOPED_LOCK(m_Lock);
 
 	bool ret = true;
 
-	if(wrap == (ResourceType)RecordType::NullResource || real == (ResourceType)RecordType::NullResource)
+	if(wrap == (WrappedResourceType)RecordType::NullResource || real == (RealResourceType)RecordType::NullResource)
 	{
 		RDCERR("Invalid state creating resource wrapper - wrapped or real resource is NULL");
 		ret = false;
 	}
 
-	if(m_WrapperMap[real] != (ResourceType)RecordType::NullResource)
+	if(m_WrapperMap[real] != (WrappedResourceType)RecordType::NullResource)
 	{
 		RDCERR("Overriding wrapper for resource");
 		ret = false;
@@ -1103,12 +1103,12 @@ bool ResourceManager<ResourceType, RecordType>::AddWrapper(ResourceType wrap, Re
 	return ret;
 }
 
-template<typename ResourceType, typename RecordType>
-void ResourceManager<ResourceType, RecordType>::RemoveWrapper(ResourceType real)
+template<typename WrappedResourceType, typename RealResourceType, typename RecordType>
+void ResourceManager<WrappedResourceType, RealResourceType, RecordType>::RemoveWrapper(RealResourceType real)
 {
 	SCOPED_LOCK(m_Lock);
 	
-	if(real == (ResourceType)RecordType::NullResource || !HasWrapper(real))
+	if(real == (RealResourceType)RecordType::NullResource || !HasWrapper(real))
 	{
 		RDCERR("Invalid state removing resource wrapper - real resource is NULL or doesn't have wrapper");
 		return;
@@ -1117,26 +1117,26 @@ void ResourceManager<ResourceType, RecordType>::RemoveWrapper(ResourceType real)
 	m_WrapperMap.erase( m_WrapperMap.find(real) );
 }
 
-template<typename ResourceType, typename RecordType>
-bool ResourceManager<ResourceType, RecordType>::HasWrapper(ResourceType real)
+template<typename WrappedResourceType, typename RealResourceType, typename RecordType>
+bool ResourceManager<WrappedResourceType, RealResourceType, RecordType>::HasWrapper(RealResourceType real)
 {
 	SCOPED_LOCK(m_Lock);
 
-	if(real == (ResourceType)RecordType::NullResource)
+	if(real == (RealResourceType)RecordType::NullResource)
 		return false;
 
 	return (m_WrapperMap.find(real) != m_WrapperMap.end());
 }
 
-template<typename ResourceType, typename RecordType>
-ResourceType ResourceManager<ResourceType, RecordType>::GetWrapper(ResourceType real)
+template<typename WrappedResourceType, typename RealResourceType, typename RecordType>
+WrappedResourceType ResourceManager<WrappedResourceType, RealResourceType, RecordType>::GetWrapper(RealResourceType real)
 {
 	SCOPED_LOCK(m_Lock);
 	
-	if(real == (ResourceType)RecordType::NullResource)
-		return (ResourceType)RecordType::NullResource;
+	if(real == (RealResourceType)RecordType::NullResource)
+		return (RealResourceType)RecordType::NullResource;
 
-	if(real != (ResourceType)RecordType::NullResource && !HasWrapper(real))
+	if(real != (RealResourceType)RecordType::NullResource && !HasWrapper(real))
 	{
 		RDCERR("Invalid state removing resource wrapper - real resource isn't NULL and doesn't have wrapper");
 	}
@@ -1144,12 +1144,12 @@ ResourceType ResourceManager<ResourceType, RecordType>::GetWrapper(ResourceType
 	return m_WrapperMap[real];
 }
 
-template<typename ResourceType, typename RecordType>
-void ResourceManager<ResourceType, RecordType>::AddLiveResource(ResourceId origid, ResourceType livePtr)
+template<typename WrappedResourceType, typename RealResourceType, typename RecordType>
+void ResourceManager<WrappedResourceType, RealResourceType, RecordType>::AddLiveResource(ResourceId origid, WrappedResourceType livePtr)
 {
 	SCOPED_LOCK(m_Lock);
 	
-	if(origid == ResourceId() || livePtr == (ResourceType)RecordType::NullResource)
+	if(origid == ResourceId() || livePtr == (WrappedResourceType)RecordType::NullResource)
 	{
 		RDCERR("Invalid state adding resource mapping - id is invalid or live pointer is NULL");
 	}
@@ -1175,8 +1175,8 @@ void ResourceManager<ResourceType, RecordType>::AddLiveResource(ResourceId origi
 		m_LiveResourceMap[origid] = livePtr;
 }
 
-template<typename ResourceType, typename RecordType>
-bool ResourceManager<ResourceType, RecordType>::HasLiveResource(ResourceId origid)
+template<typename WrappedResourceType, typename RealResourceType, typename RecordType>
+bool ResourceManager<WrappedResourceType, RealResourceType, RecordType>::HasLiveResource(ResourceId origid)
 {
 	SCOPED_LOCK(m_Lock);
 
@@ -1188,13 +1188,13 @@ bool ResourceManager<ResourceType, RecordType>::HasLiveResource(ResourceId origi
 			m_LiveResourceMap.find(origid) != m_LiveResourceMap.end());
 }
 
-template<typename ResourceType, typename RecordType>
-ResourceType ResourceManager<ResourceType, RecordType>::GetLiveResource(ResourceId origid)
+template<typename WrappedResourceType, typename RealResourceType, typename RecordType>
+WrappedResourceType ResourceManager<WrappedResourceType, RealResourceType, RecordType>::GetLiveResource(ResourceId origid)
 {
 	SCOPED_LOCK(m_Lock);
 
 	if(origid == ResourceId())
-		return (ResourceType)RecordType::NullResource;
+		return (WrappedResourceType)RecordType::NullResource;
 
 	RDCASSERT(HasLiveResource(origid));
 	
@@ -1207,11 +1207,11 @@ ResourceType ResourceManager<ResourceType, RecordType>::GetLiveResource(Resource
 	if(m_LiveResourceMap.find(origid) != m_LiveResourceMap.end())
 		return m_LiveResourceMap[origid];
 
-	return (ResourceType)RecordType::NullResource;
+	return (WrappedResourceType)RecordType::NullResource;
 }
 
-template<typename ResourceType, typename RecordType>
-void ResourceManager<ResourceType, RecordType>::EraseLiveResource(ResourceId origid)
+template<typename WrappedResourceType, typename RealResourceType, typename RecordType>
+void ResourceManager<WrappedResourceType, RealResourceType, RecordType>::EraseLiveResource(ResourceId origid)
 {
 	SCOPED_LOCK(m_Lock);
 
@@ -1227,8 +1227,8 @@ void ResourceManager<ResourceType, RecordType>::EraseLiveResource(ResourceId ori
 	}
 }
 
-template<typename ResourceType, typename RecordType>
-void ResourceManager<ResourceType, RecordType>::AddCurrentResource(ResourceId id, ResourceType res)
+template<typename WrappedResourceType, typename RealResourceType, typename RecordType>
+void ResourceManager<WrappedResourceType, RealResourceType, RecordType>::AddCurrentResource(ResourceId id, WrappedResourceType res)
 {
 	SCOPED_LOCK(m_Lock);
 
@@ -1236,16 +1236,16 @@ void ResourceManager<ResourceType, RecordType>::AddCurrentResource(ResourceId id
 	m_CurrentResourceMap[id] = res;
 }
 
-template<typename ResourceType, typename RecordType>
-bool ResourceManager<ResourceType, RecordType>::HasCurrentResource(ResourceId id)
+template<typename WrappedResourceType, typename RealResourceType, typename RecordType>
+bool ResourceManager<WrappedResourceType, RealResourceType, RecordType>::HasCurrentResource(ResourceId id)
 {
 	SCOPED_LOCK(m_Lock);
 
 	return m_CurrentResourceMap.find(id) != m_CurrentResourceMap.end();
 }
 
-template<typename ResourceType, typename RecordType>
-ResourceType ResourceManager<ResourceType, RecordType>::GetCurrentResource(ResourceId id)
+template<typename WrappedResourceType, typename RealResourceType, typename RecordType>
+WrappedResourceType ResourceManager<WrappedResourceType, RealResourceType, RecordType>::GetCurrentResource(ResourceId id)
 {
 	SCOPED_LOCK(m_Lock);
 
@@ -1253,8 +1253,8 @@ ResourceType ResourceManager<ResourceType, RecordType>::GetCurrentResource(Resou
 	return m_CurrentResourceMap[id];
 }
 
-template<typename ResourceType, typename RecordType>
-void ResourceManager<ResourceType, RecordType>::ReleaseCurrentResource(ResourceId id)
+template<typename WrappedResourceType, typename RealResourceType, typename RecordType>
+void ResourceManager<WrappedResourceType, RealResourceType, RecordType>::ReleaseCurrentResource(ResourceId id)
 {
 	SCOPED_LOCK(m_Lock);
 
@@ -1262,8 +1262,8 @@ void ResourceManager<ResourceType, RecordType>::ReleaseCurrentResource(ResourceI
 	m_CurrentResourceMap.erase(id);
 }
 
-template<typename ResourceType, typename RecordType>
-ResourceId ResourceManager<ResourceType, RecordType>::GetOriginalID(ResourceId id)
+template<typename WrappedResourceType, typename RealResourceType, typename RecordType>
+ResourceId ResourceManager<WrappedResourceType, RealResourceType, RecordType>::GetOriginalID(ResourceId id)
 {
 	if(id == ResourceId())
 		return id;
@@ -1272,8 +1272,8 @@ ResourceId ResourceManager<ResourceType, RecordType>::GetOriginalID(ResourceId i
 	return m_OriginalIDs[id];
 }
 
-template<typename ResourceType, typename RecordType>
-ResourceId ResourceManager<ResourceType, RecordType>::GetLiveID(ResourceId id)
+template<typename WrappedResourceType, typename RealResourceType, typename RecordType>
+ResourceId ResourceManager<WrappedResourceType, RealResourceType, RecordType>::GetLiveID(ResourceId id)
 {
 	if(id == ResourceId())
 		return id;

renderdoc/driver/d3d11/d3d11_manager.h

@@ -132,7 +132,7 @@ private:
 	bool contexts[32];
 };
 
-class D3D11ResourceManager : public ResourceManager<ID3D11DeviceChild*, D3D11ResourceRecord>
+class D3D11ResourceManager : public ResourceManager<ID3D11DeviceChild*, ID3D11DeviceChild*, D3D11ResourceRecord>
 {
 	public:
 		D3D11ResourceManager(LogState state, Serialiser *ser, WrappedID3D11Device *dev)

renderdoc/driver/gl/gl_manager.h

@@ -31,7 +31,7 @@
 
 class WrappedOpenGL;
 
-class GLResourceManager : public ResourceManager<GLResource, GLResourceRecord>
+class GLResourceManager : public ResourceManager<GLResource, GLResource, GLResourceRecord>
 {
 	public: 
 		GLResourceManager(LogState state, Serialiser *ser, WrappedOpenGL *gl)

renderdoc/driver/vulkan/vk_core.cpp

@@ -1083,7 +1083,7 @@ VkResult WrappedVulkan::vkGetGlobalExtensionProperties(
 		GetResourceManager()->ReleaseCurrentResource(wrapped->id); \
 		if(wrapped->record) wrapped->record->Delete(GetResourceManager()); \
 		if(m_ImageInfo.find(wrapped->id) != m_ImageInfo.end()) m_ImageInfo.erase(wrapped->id); \
-		return ObjDisp(device)->func(Unwrap(device), type(wrapped->real)); \
+		return ObjDisp(device)->func(Unwrap(device), wrapped->real.As<type>()); \
 	}
 
 DESTROY_IMPL(VkBuffer, DestroyBuffer)
@@ -1117,7 +1117,7 @@ VkResult WrappedVulkan::vkDestroyCommandBuffer(VkDevice device, VkCmdBuffer obj)
 	WrappedVkDispRes *wrapped = (WrappedVkDispRes *)GetWrapped(obj);
 	GetResourceManager()->MarkCleanResource(wrapped->id);
 	if(wrapped->record) wrapped->record->Delete(GetResourceManager());
-	return ObjDisp(device)->DestroyCommandBuffer(Unwrap(device), (VkCmdBuffer)(uintptr_t)wrapped->real);
+	return ObjDisp(device)->DestroyCommandBuffer(Unwrap(device), wrapped->real.As<VkCmdBuffer>());
 }
 
 
@@ -1664,7 +1664,7 @@ VkResult WrappedVulkan::vkFreeMemory(
 	if(wrapped->record) wrapped->record->Delete(GetResourceManager());
 	GetResourceManager()->ReleaseCurrentResource(wrapped->id);
 
-	return ObjDisp(device)->FreeMemory(Unwrap(device), VkDeviceMemory(wrapped->real));
+	return ObjDisp(device)->FreeMemory(Unwrap(device), wrapped->real.As<VkDeviceMemory>());
 }
 
 VkResult WrappedVulkan::vkMapMemory(
@@ -5669,87 +5669,87 @@ bool WrappedVulkan::ReleaseResource(WrappedVkRes *res)
 
 		case eResInstance:
 		{
-			VkInstance instance = (VkInstance)disp->real;
+			VkInstance instance = disp->real.As<VkInstance>();
 			dispatch_key key = get_dispatch_key(instance);
 			ObjDisp(instance)->DestroyInstance(instance);
 			destroy_instance_dispatch_table(key);
 			break;
 		}
 		case eResDevice:
-			vt->DestroyDevice((VkDevice)disp->real);
+			vt->DestroyDevice(disp->real.As<VkDevice>());
 			break;
 		case eResDeviceMemory:
-			vt->FreeMemory(dev, (VkDeviceMemory)nondisp->real);
+			vt->FreeMemory(dev, nondisp->real.As<VkDeviceMemory>());
 			break;
 		case eResBuffer:
-			vt->DestroyBuffer(dev, (VkBuffer)nondisp->real);
+			vt->DestroyBuffer(dev, nondisp->real.As<VkBuffer>());
 			break;
 		case eResBufferView:
-			vt->DestroyBufferView(dev, (VkBufferView)nondisp->real);
+			vt->DestroyBufferView(dev, nondisp->real.As<VkBufferView>());
 			break;
 		case eResImage:
-			vt->DestroyImage(dev, (VkImage)nondisp->real);
+			vt->DestroyImage(dev, nondisp->real.As<VkImage>());
 			break;
 		case eResImageView:
-			vt->DestroyImageView(dev, (VkImageView)nondisp->real);
+			vt->DestroyImageView(dev, nondisp->real.As<VkImageView>());
 			break;
 		case eResAttachmentView:
-			vt->DestroyAttachmentView(dev, (VkAttachmentView)nondisp->real);
+			vt->DestroyAttachmentView(dev, nondisp->real.As<VkAttachmentView>());
 			break;
 		case eResFramebuffer:
-			vt->DestroyFramebuffer(dev, (VkFramebuffer)nondisp->real);
+			vt->DestroyFramebuffer(dev, nondisp->real.As<VkFramebuffer>());
 			break;
 		case eResRenderPass:
-			vt->DestroyRenderPass(dev, (VkRenderPass)nondisp->real);
+			vt->DestroyRenderPass(dev, nondisp->real.As<VkRenderPass>());
 			break;
 		case eResShaderModule:
-			vt->DestroyShaderModule(dev, (VkShaderModule)nondisp->real);
+			vt->DestroyShaderModule(dev, nondisp->real.As<VkShaderModule>());
 			break;
 		case eResShader:
-			vt->DestroyShader(dev, (VkShader)nondisp->real);
+			vt->DestroyShader(dev, nondisp->real.As<VkShader>());
 			break;
 		case eResPipelineCache:
-			vt->DestroyPipelineCache(dev, (VkPipelineCache)nondisp->real);
+			vt->DestroyPipelineCache(dev, nondisp->real.As<VkPipelineCache>());
 			break;
 		case eResPipelineLayout:
-			vt->DestroyPipelineLayout(dev, (VkPipelineLayout)nondisp->real);
+			vt->DestroyPipelineLayout(dev, nondisp->real.As<VkPipelineLayout>());
 			break;
 		case eResPipeline:
-			vt->DestroyPipeline(dev, (VkPipeline)nondisp->real);
+			vt->DestroyPipeline(dev, nondisp->real.As<VkPipeline>());
 			break;
 		case eResSampler:
-			vt->DestroySampler(dev, (VkSampler)nondisp->real);
+			vt->DestroySampler(dev, nondisp->real.As<VkSampler>());
 			break;
 		case eResDescriptorPool:
-			vt->DestroyDescriptorPool(dev, (VkDescriptorPool)nondisp->real);
+			vt->DestroyDescriptorPool(dev, nondisp->real.As<VkDescriptorPool>());
 			break;
 		case eResDescriptorSetLayout:
-			vt->DestroyDescriptorSetLayout(dev, (VkDescriptorSetLayout)nondisp->real);
+			vt->DestroyDescriptorSetLayout(dev, nondisp->real.As<VkDescriptorSetLayout>());
 			break;
 		case eResViewportState:
-			vt->DestroyDynamicViewportState(dev, (VkDynamicViewportState)nondisp->real);
+			vt->DestroyDynamicViewportState(dev, nondisp->real.As<VkDynamicViewportState>());
 			break;
 		case eResRasterState:
-			vt->DestroyDynamicViewportState(dev, (VkDynamicViewportState)nondisp->real);
+			vt->DestroyDynamicViewportState(dev, nondisp->real.As<VkDynamicViewportState>());
 			break;
 		case eResColorBlendState:
-			vt->DestroyDynamicColorBlendState(dev, (VkDynamicColorBlendState)nondisp->real);
+			vt->DestroyDynamicColorBlendState(dev, nondisp->real.As<VkDynamicColorBlendState>());
 			break;
 		case eResDepthStencilState:
-			vt->DestroyDynamicDepthStencilState(dev, (VkDynamicDepthStencilState)nondisp->real);
+			vt->DestroyDynamicDepthStencilState(dev, nondisp->real.As<VkDynamicDepthStencilState>());
 			break;
 		case eResCmdPool:
-			vt->DestroyCommandPool(dev, (VkCmdPool)nondisp->real);
+			vt->DestroyCommandPool(dev, nondisp->real.As<VkCmdPool>());
 			break;
 		case eResCmdBuffer:
-			vt->DestroyCommandBuffer(dev, (VkCmdBuffer)disp->real);
+			vt->DestroyCommandBuffer(dev, disp->real.As<VkCmdBuffer>());
 			break;
 		case eResFence:
 			// VKTODOLOW
-			//vt->DestroyFence(dev, (VkFence)nondisp->real);
+			//vt->DestroyFence(dev, nondisp->real.As<VkFence>());
 			break;
 		case eResSemaphore:
-			vt->DestroySemaphore(dev, (VkSemaphore)nondisp->real);
+			vt->DestroySemaphore(dev, nondisp->real.As<VkSemaphore>());
 			break;
 	}
 
@@ -7731,8 +7731,8 @@ void WrappedVulkan::Apply_InitialState(WrappedVkRes *live, VulkanResourceManager
 
 		MemState &meminfo = m_MemoryInfo[id];
 		
-		VkBuffer srcBuf = (VkBuffer)(uintptr_t)initial.resource;
-		VkDeviceMemory dstMem = (VkDeviceMemory)(uintptr_t)live; // maintain the wrapping, for consistency
+		VkBuffer srcBuf = (VkBuffer)(uint64_t)initial.resource;
+		VkDeviceMemory dstMem = (VkDeviceMemory)(uint64_t)live; // maintain the wrapping, for consistency
 
 		VkResult vkr = VK_SUCCESS;
 

renderdoc/driver/vulkan/vk_core.h

@@ -57,8 +57,8 @@ void SetDispatchTable(bool writing, wrappedtype *wrapped)
 	if(writing)
 	{
 		wrapped->table = wrappedtype::UseInstanceDispatchTable
-			? (uintptr_t)instance_dispatch_table((void *)wrapped->real)
-			: (uintptr_t)device_dispatch_table((void *)wrapped->real);
+			? (uintptr_t)instance_dispatch_table((void *)wrapped->real.handle)
+			: (uintptr_t)device_dispatch_table((void *)wrapped->real.handle);
 	}
 	else
 	{

renderdoc/driver/vulkan/vk_manager.h

@@ -35,7 +35,7 @@ using std::pair;
 
 class WrappedVulkan;
 
-class VulkanResourceManager : public ResourceManager<WrappedVkRes*, VkResourceRecord>
+class VulkanResourceManager : public ResourceManager<WrappedVkRes*, RealVkRes, VkResourceRecord>
 {
 	public: 
 		VulkanResourceManager(LogState s, Serialiser *ser, WrappedVulkan *core)
@@ -72,13 +72,13 @@ class VulkanResourceManager : public ResourceManager<WrappedVkRes*, VkResourceRe
 		template<typename realtype>
 		realtype GetLiveHandle(ResourceId origid)
 		{
-			return UnwrapHelper<realtype>::ToHandle( ((typename UnwrapHelper<realtype>::ParentType *)ResourceManager::GetLiveResource(origid))->real );
+			return ((typename UnwrapHelper<realtype>::ParentType *)ResourceManager::GetLiveResource(origid))->real.As<realtype>();
 		}
 
 		template<typename realtype>
 		realtype GetCurrentHandle(ResourceId id)
 		{
-			return UnwrapHelper<realtype>::ToHandle( ((typename UnwrapHelper<realtype>::ParentType *)ResourceManager::GetCurrentResource(id))->real );
+			return ((typename UnwrapHelper<realtype>::ParentType *)ResourceManager::GetCurrentResource(id))->real.As<realtype>();
 		}
 		
 		// handling memory & image transitions
@@ -111,7 +111,9 @@ class VulkanResourceManager : public ResourceManager<WrappedVkRes*, VkResourceRe
 
 			AddCurrentResource(id, wrapped);
 
-			obj = UnwrapHelper<realtype>::ToHandle((uint64_t)(uintptr_t)wrapped);
+			AddWrapper(wrapped, UnwrapHelper<realtype>::ToRealRes(obj));
+
+			obj = realtype((uint64_t)wrapped);
 
 			return id;
 		}

renderdoc/driver/vulkan/vk_resources.h

@@ -45,11 +45,27 @@ struct WrappedVkRes
 {
 };
 
+// dummy standin for a typeless real resource
+// stored in a uint64_t, with function to cast back
+// if we know what type it is
+struct RealVkRes
+{
+	RealVkRes() : handle(VK_NULL_HANDLE) {} 
+	RealVkRes(void *disp) : handle((uint64_t)disp) {}
+	RealVkRes(uint64_t nondisp) : handle(nondisp) {}
+
+	bool operator ==(const RealVkRes o) const { return handle == o.handle; }
+	bool operator < (const RealVkRes o) const { return handle <  o.handle; }
+
+	uint64_t handle;
+	template<typename T> T As() { return (T)handle; }
+};
+
 struct WrappedVkNonDispRes : public WrappedVkRes
 {
 	template<typename T> WrappedVkNonDispRes(T obj, ResourceId objId) : real(obj.handle), id(objId), record(NULL) {}
 	
-	uint64_t real;
+	RealVkRes real;
 	ResourceId id;
 	union
 	{
@@ -61,26 +77,26 @@ struct WrappedVkNonDispRes : public WrappedVkRes
 
 struct WrappedVkDispRes : public WrappedVkRes
 {
-	WrappedVkDispRes(VkInstance obj, ResourceId objId) : table(0), real((uint64_t)(uintptr_t)obj), id(objId), record(NULL)
+	WrappedVkDispRes(VkInstance obj, ResourceId objId) : table(0), real((void *)obj), id(objId), record(NULL)
 	{ loaderTable = *(uintptr_t*)obj; }
 
-	WrappedVkDispRes(VkPhysicalDevice obj, ResourceId objId) : table(0), real((uint64_t)(uintptr_t)obj), id(objId), record(NULL)
+	WrappedVkDispRes(VkPhysicalDevice obj, ResourceId objId) : table(0), real((void *)obj), id(objId), record(NULL)
 	{ loaderTable = *(uintptr_t*)obj; }
 	
-	WrappedVkDispRes(VkDevice obj, ResourceId objId) : table(0), real((uint64_t)(uintptr_t)obj), id(objId), record(NULL)
+	WrappedVkDispRes(VkDevice obj, ResourceId objId) : table(0), real((void *)obj), id(objId), record(NULL)
 	{ loaderTable = *(uintptr_t*)obj; }
 
-	WrappedVkDispRes(VkQueue obj, ResourceId objId) : table(0), real((uint64_t)(uintptr_t)obj), id(objId), record(NULL)
+	WrappedVkDispRes(VkQueue obj, ResourceId objId) : table(0), real((void *)obj), id(objId), record(NULL)
 	{ loaderTable = *(uintptr_t*)obj; }
 
-	WrappedVkDispRes(VkCmdBuffer obj, ResourceId objId) : table(0), real((uint64_t)(uintptr_t)obj), id(objId), record(NULL)
+	WrappedVkDispRes(VkCmdBuffer obj, ResourceId objId) : table(0), real((void *)obj), id(objId), record(NULL)
 	{ loaderTable = *(uintptr_t*)obj; }
 
 	// VKTODOLOW there's padding here on 32-bit but I don't know if I really care about 32-bit.
 
 	// preserve dispatch table pointer in dispatchable objects
 	uintptr_t loaderTable, table;
-	uint64_t real;
+	RealVkRes real;
 	ResourceId id;
 	union
 	{
@@ -91,7 +107,7 @@ struct WrappedVkDispRes : public WrappedVkRes
 };
 
 // ensure the structs don't accidentally get made larger
-RDCCOMPILE_ASSERT(sizeof(WrappedVkDispRes) == sizeof(uint64_t)*5, "Wrapped resource struct has changed size! This is bad");
+RDCCOMPILE_ASSERT(sizeof(WrappedVkDispRes) == (sizeof(uint64_t)*3 + sizeof(uintptr_t)*2), "Wrapped resource struct has changed size! This is bad");
 RDCCOMPILE_ASSERT(sizeof(WrappedVkNonDispRes) == sizeof(uint64_t)*3, "Wrapped resource struct has changed size! This is bad");
 
 // VKTODOLOW check that the pool counts approximated below are good for typical applications
@@ -312,7 +328,7 @@ template<typename inner> struct UnwrapHelper {};
 	{ \
 		typedef WrappedVkDispRes ParentType; \
 		typedef CONCAT(Wrapped, vulkantype) Outer; \
-		static vulkantype ToHandle(uint64_t real) { return (vulkantype) (uintptr_t)real; } \
+		static RealVkRes ToRealRes(vulkantype real) { return RealVkRes((void *)real); } \
 		static Outer *FromHandle(vulkantype wrapped) { return (Outer *) wrapped; } \
 	};
 
@@ -321,7 +337,7 @@ template<typename inner> struct UnwrapHelper {};
 	{ \
 		typedef WrappedVkNonDispRes ParentType; \
 		typedef CONCAT(Wrapped, vulkantype) Outer; \
-		static vulkantype ToHandle(uint64_t real) { return vulkantype(real); } \
+		static RealVkRes ToRealRes(vulkantype real) { return RealVkRes(real.handle); } \
 		static Outer *FromHandle(vulkantype wrapped) { return (Outer *) (uintptr_t)wrapped.handle; } \
 	};
 
@@ -389,7 +405,7 @@ RealType Unwrap(RealType obj)
 {
 	if(obj == VK_NULL_HANDLE) return VK_NULL_HANDLE;
 
-	return UnwrapHelper<RealType>::ToHandle(GetWrapped(obj)->real);
+	return GetWrapped(obj)->real.As<RealType>();
 }
 
 template<typename RealType>
@@ -411,7 +427,7 @@ VkResourceRecord *GetRecord(RealType obj)
 template<typename RealType>
 RealType ToHandle(WrappedVkRes *ptr)
 {
-	return UnwrapHelper<RealType>::ToHandle( ((typename UnwrapHelper<RealType>::Outer *)ptr)->real );
+	return ((typename UnwrapHelper<RealType>::Outer *)ptr)->real.As<RealType>();
 }
 
 enum VkResourceType