Use ToStr() instead of %llu to format Resource IDs

renderdoc/driver/d3d11/d3d11_context.cpp

@@ -343,7 +343,8 @@ bool WrappedID3D11DeviceContext::Serialise_BeginCaptureFrame(SerialiserType &ser
       if(hr != S_OK)
       {
         numPrims.NumPrimitivesWritten = 0;
-        RDCERR("Couldn't retrieve hidden buffer counter for streamout on buffer %llu", it->first);
+        RDCERR("Couldn't retrieve hidden buffer counter for streamout on buffer %s",
+               ToStr(it->first).c_str());
       }
 
       HiddenStreamOutCounters.push_back({it->first, (uint64_t)numPrims.NumPrimitivesWritten});
@@ -485,8 +486,8 @@ void WrappedID3D11DeviceContext::AttemptCapture()
   // successful.
   if(GetType() == D3D11_DEVICE_CONTEXT_DEFERRED)
   {
-    RDCDEBUG("Deferred Context %llu Attempting capture - initially %s, %s", GetResourceID(),
-             m_SuccessfulCapture ? "successful" : "unsuccessful",
+    RDCDEBUG("Deferred Context %s Attempting capture - initially %s, %s",
+             ToStr(GetResourceID()).c_str(), m_SuccessfulCapture ? "successful" : "unsuccessful",
              m_EmptyCommandList ? "empty" : "non-empty");
 
     m_SuccessfulCapture |= m_EmptyCommandList;
@@ -496,12 +497,12 @@ void WrappedID3D11DeviceContext::AttemptCapture()
     else
       m_FailureReason = CaptureFailed_UncappedCmdlist;
 
-    RDCDEBUG("Deferred Context %llu Attempting capture - now %s", GetResourceID(),
+    RDCDEBUG("Deferred Context %s Attempting capture - now %s", ToStr(GetResourceID()).c_str(),
              m_SuccessfulCapture ? "successful" : "unsuccessful");
   }
   else
   {
-    RDCDEBUG("Immediate Context %llu Attempting capture", GetResourceID());
+    RDCDEBUG("Immediate Context %s Attempting capture", ToStr(GetResourceID()).c_str());
 
     m_SuccessfulCapture = true;
     m_FailureReason = CaptureSucceeded;

renderdoc/driver/d3d11/d3d11_context_wrap.cpp

@@ -5252,14 +5252,14 @@ void WrappedID3D11DeviceContext::ExecuteCommandList(ID3D11CommandList *pCommandL
     if(!wrapped->IsCaptured())
     {
       // we don't have this command list captured. This frame is no longer successful
-      RDCWARN("Don't have command list %llu captured! This frame is unsuccessful.",
-              wrapped->GetResourceID());
+      RDCWARN("Don't have command list %s captured! This frame is unsuccessful.",
+              ToStr(wrapped->GetResourceID()).c_str());
       m_SuccessfulCapture = false;
       m_FailureReason = CaptureFailed_UncappedCmdlist;
     }
     else
     {
-      RDCDEBUG("Executed successful command list %llu", wrapped->GetResourceID());
+      RDCDEBUG("Executed successful command list %s", ToStr(wrapped->GetResourceID()).c_str());
       ResourceId contextId = wrapped->GetResourceID();
 
       D3D11ResourceRecord *cmdListRecord =
@@ -5399,8 +5399,8 @@ HRESULT WrappedID3D11DeviceContext::FinishCommandList(BOOL RestoreDeferredContex
       // list
       if(m_SuccessfulCapture)
       {
-        RDCDEBUG("Deferred Context %llu Finish()'d successfully! Got successful command list %llu",
-                 GetResourceID(), wrapped->GetResourceID());
+        RDCDEBUG("Deferred Context %s Finish()'d successfully! Got successful command list %s",
+                 ToStr(GetResourceID()).c_str(), ToStr(wrapped->GetResourceID()).c_str());
 
         RDCASSERT(wrapped->IsCaptured());
 
@@ -5428,9 +5428,9 @@ HRESULT WrappedID3D11DeviceContext::FinishCommandList(BOOL RestoreDeferredContex
       else    // !m_SuccessfulCapture
       {
         RDCDEBUG(
-            "Deferred Context %llu wasn't successful, but now we've Finish()'d so it is! Produced "
-            "unsuccessful command list %llu.",
-            GetResourceID(), wrapped->GetResourceID());
+            "Deferred Context %s wasn't successful, but now we've Finish()'d so it is! Produced "
+            "unsuccessful command list %s.",
+            ToStr(GetResourceID()).c_str(), ToStr(wrapped->GetResourceID()).c_str());
 
         RDCASSERT(!wrapped->IsCaptured());
 
@@ -5494,9 +5494,8 @@ HRESULT WrappedID3D11DeviceContext::FinishCommandList(BOOL RestoreDeferredContex
       m_DeferredReferences.clear();
 
       RDCDEBUG(
-          "Deferred Context %llu not capturing at the moment, Produced unsuccessful command list "
-          "%llu.",
-          GetResourceID(), wrapped->GetResourceID());
+          "Deferred Context %s not capturing at the moment, Produced unsuccessful command list %s.",
+          ToStr(GetResourceID()).c_str(), ToStr(wrapped->GetResourceID()).c_str());
     }
   }
 
@@ -7705,7 +7704,8 @@ bool WrappedID3D11DeviceContext::Serialise_Unmap(SerialiserType &ser, ID3D11Reso
     }
     else
     {
-      RDCERR("Couldn't find map for %llu/%u in open maps list", mapIdx.resource, mapIdx.subresource);
+      RDCERR("Couldn't find map for %s/%u in open maps list", ToStr(mapIdx.resource).c_str(),
+             mapIdx.subresource);
     }
 
     MapWrittenData = (byte *)intercept.app.pData;

renderdoc/driver/d3d11/d3d11_initstate.cpp

@@ -35,7 +35,7 @@ bool WrappedID3D11Device::Prepare_InitialState(ID3D11DeviceChild *res)
   RDCASSERT(IsCaptureMode(m_State));
 
   {
-    RDCDEBUG("Prepare_InitialState(%llu)", Id);
+    RDCDEBUG("Prepare_InitialState(%s)", ToStr(Id).c_str());
 
     if(type == Resource_Buffer)
       RDCDEBUG("    .. buffer");
@@ -397,7 +397,7 @@ bool WrappedID3D11Device::Serialise_InitialState(SerialiserType &ser, ResourceId
   }
 
   {
-    RDCDEBUG("Serialise_InitialState(%llu)", id);
+    RDCDEBUG("Serialise_InitialState(%s)", ToStr(id).c_str());
 
     if(type == Resource_Buffer)
       RDCDEBUG("    .. buffer");
@@ -472,9 +472,9 @@ bool WrappedID3D11Device::Serialise_InitialState(SerialiserType &ser, ResourceId
         hr = m_pImmediateContext->GetReal()->Map(stage, 0, D3D11_MAP_READ, 0, &mapped);
       else
         RDCERR(
-            "Didn't have stage resource for %llu when serialising initial state! "
+            "Didn't have stage resource for %s when serialising initial state! "
             "Dirty tracking is incorrect",
-            id);
+            ToStr(id).c_str());
 
       if(FAILED(hr))
       {
@@ -535,9 +535,9 @@ bool WrappedID3D11Device::Serialise_InitialState(SerialiserType &ser, ResourceId
           hr = m_pImmediateContext->GetReal()->Map(prepared, sub, D3D11_MAP_READ, 0, &mapped);
         else
           RDCERR(
-              "Didn't have stage resource for %llu when serialising initial state! "
+              "Didn't have stage resource for %s when serialising initial state! "
               "Dirty tracking is incorrect",
-              id);
+              ToStr(id).c_str());
 
         if(FAILED(hr))
           RDCERR("Failed to map in initial states %s", ToStr(hr).c_str());
@@ -684,9 +684,9 @@ bool WrappedID3D11Device::Serialise_InitialState(SerialiserType &ser, ResourceId
             hr = m_pImmediateContext->GetReal()->Map(prepared, sub, D3D11_MAP_READ, 0, &mapped);
           else
             RDCERR(
-                "Didn't have stage resource for %llu when serialising initial state! "
+                "Didn't have stage resource for %s when serialising initial state! "
                 "Dirty tracking is incorrect",
-                id);
+                ToStr(id).c_str());
 
           if(FAILED(hr))
           {
@@ -856,9 +856,9 @@ bool WrappedID3D11Device::Serialise_InitialState(SerialiserType &ser, ResourceId
           hr = m_pImmediateContext->GetReal()->Map(prepared, sub, D3D11_MAP_READ, 0, &mapped);
         else
           RDCERR(
-              "Didn't have stage resource for %llu when serialising initial state! "
+              "Didn't have stage resource for %s when serialising initial state! "
               "Dirty tracking is incorrect",
-              id);
+              ToStr(id).c_str());
 
         if(FAILED(hr))
         {
@@ -953,7 +953,7 @@ void WrappedID3D11Device::Create_InitialState(ResourceId id, ID3D11DeviceChild *
   D3D11ResourceType type = IdentifyTypeByPtr(live);
 
   {
-    RDCDEBUG("Create_InitialState(%llu)", id);
+    RDCDEBUG("Create_InitialState(%s)", ToStr(id).c_str());
 
     if(type == Resource_Buffer)
       RDCDEBUG("    .. buffer");

renderdoc/driver/d3d11/d3d11_pixelhistory.cpp

@@ -302,9 +302,9 @@ rdcarray<PixelModification> D3D11Replay::PixelHistory(rdcarray<EventUsage> event
   uint32_t mip = sub.mip;
   uint32_t sampleIdx = sub.sample;
 
-  D3D11MarkerRegion historyMarker(
-      StringFormat::Fmt("Doing PixelHistory on %llu, (%u,%u) %u, %u, %u over %u events", target, x,
-                        y, slice, mip, sampleIdx, (uint32_t)events.size()));
+  D3D11MarkerRegion historyMarker(StringFormat::Fmt(
+      "Doing PixelHistory on %s, (%u,%u) %u, %u, %u over %u events", ToStr(target).c_str(), x, y,
+      slice, mip, sampleIdx, (uint32_t)events.size()));
 
   // Use the given type hint for typeless textures
   details.texFmt = GetTypedFormat(details.texFmt, typeCast);
@@ -331,8 +331,8 @@ rdcarray<PixelModification> D3D11Replay::PixelHistory(rdcarray<EventUsage> event
   float xf = (float)x;
   float yf = (float)y;
 
-  RDCDEBUG("Checking Pixel History on %llu (%u, %u) with %u possible events", target, x, y,
-           (uint32_t)events.size());
+  RDCDEBUG("Checking Pixel History on %s (%u, %u) with %u possible events", ToStr(target).c_str(),
+           x, y, (uint32_t)events.size());
 
   // these occlusion queries are run with every test possible disabled
   rdcarray<ID3D11Query *> occl;
@@ -1400,7 +1400,7 @@ rdcarray<PixelModification> D3D11Replay::PixelHistory(rdcarray<EventUsage> event
       }
       else
       {
-        RDCWARN("Unexpected view type, ID %llu. Assuming used...", events[i].view);
+        RDCWARN("Unexpected view type, ID %s. Assuming used...", ToStr(events[i].view).c_str());
         used = true;
       }
 

renderdoc/driver/d3d11/d3d11_replay.cpp

@@ -414,7 +414,7 @@ TextureDescription D3D11Replay::GetTexture(ResourceId id)
     return tex;
   }
 
-  RDCERR("Unrecognised/unknown texture %llu", id);
+  RDCERR("Unrecognised/unknown texture %s", ToStr(id).c_str());
 
   tex.byteSize = 0;
   tex.dimension = 2;
@@ -1937,7 +1937,7 @@ void D3D11Replay::GetBufferData(ResourceId buff, uint64_t offset, uint64_t lengt
 
   if(it == WrappedID3D11Buffer::m_BufferList.end())
   {
-    RDCERR("Getting buffer data for unknown buffer %llu!", buff);
+    RDCERR("Getting buffer data for unknown buffer %s!", ToStr(buff).c_str());
     return;
   }
 
@@ -2447,7 +2447,7 @@ void D3D11Replay::GetTextureData(ResourceId tex, const Subresource &sub,
   }
   else
   {
-    RDCERR("Trying to get texture data for unknown ID %llu!", tex);
+    RDCERR("Trying to get texture data for unknown ID %s!", ToStr(tex).c_str());
     return;
   }
 

renderdoc/driver/d3d12/d3d12_command_list_wrap.cpp

@@ -92,8 +92,8 @@ bool WrappedID3D12GraphicsCommandList::Serialise_Close(SerialiserType &ser)
       {
         ID3D12GraphicsCommandListX *list = m_Cmd->RerecordCmdList(BakedCommandList);
 #if ENABLED(VERBOSE_PARTIAL_REPLAY)
-        RDCDEBUG("Ending re-recorded command list for %llu baked to %llu", CommandList,
-                 BakedCommandList);
+        RDCDEBUG("Ending re-recorded command list for %s baked to %s", ToStr(CommandList).c_str(),
+                 ToStr(BakedCommandList).c_str());
 #endif
 
         int &markerCount = m_Cmd->m_BakedCmdListInfo[BakedCommandList].markerCount;
@@ -229,8 +229,8 @@ bool WrappedID3D12GraphicsCommandList::Serialise_Reset(SerialiserType &ser,
           if(*it <= m_Cmd->m_LastEventID && m_Cmd->m_LastEventID < (*it + length))
           {
 #if ENABLED(VERBOSE_PARTIAL_REPLAY)
-            RDCDEBUG("Reset - partial detected %u < %u < %u, %llu -> %llu", *it,
-                     m_Cmd->m_LastEventID, *it + length, CommandList, BakedCommandList);
+            RDCDEBUG("Reset - partial detected %u < %u < %u, %s -> %s", *it, m_Cmd->m_LastEventID,
+                     *it + length, ToStr(CommandList).c_str(), ToStr(BakedCommandList).c_str());
 #endif
 
             m_Cmd->m_Partial[p].partialParent = BakedCommandList;
@@ -243,8 +243,9 @@ bool WrappedID3D12GraphicsCommandList::Serialise_Reset(SerialiserType &ser,
           else if(*it <= m_Cmd->m_LastEventID)
           {
 #if ENABLED(VERBOSE_PARTIAL_REPLAY)
-            RDCDEBUG("Reset() - full re-record detected %u < %u <= %u, %llu -> %llu", *it,
-                     *it + length, m_Cmd->m_LastEventID, m_Cmd->m_LastCmdListID, BakedCommandList);
+            RDCDEBUG("Reset() - full re-record detected %u < %u <= %u, %s -> %s", *it, *it + length,
+                     m_Cmd->m_LastEventID, ToStr(m_Cmd->m_LastCmdListID).c_str(),
+                     ToStr(BakedCommandList).c_str());
 #endif
 
             // this submission is completely within the range, so it should still be re-recorded

renderdoc/driver/d3d12/d3d12_command_queue_wrap.cpp

@@ -109,8 +109,9 @@ bool WrappedID3D12CommandQueue::Serialise_ExecuteCommandLists(SerialiserType &se
 
     if(m_PrevQueueId != GetResID(pQueue))
     {
-      RDCDEBUG("Previous queue execution was on queue %llu, now executing %llu, syncing GPU",
-               m_PrevQueueId, GetResID(pQueue));
+      RDCDEBUG("Previous queue execution was on queue %s, now executing %s, syncing GPU",
+               ToStr(GetResourceManager()->GetOriginalID(m_PrevQueueId)).c_str(),
+               ToStr(GetResourceManager()->GetOriginalID(GetResID(pQueue))).c_str());
       if(m_PrevQueueId != ResourceId())
         m_pDevice->GPUSync(GetResourceManager()->GetCurrentAs<ID3D12CommandQueue>(m_PrevQueueId));
 
@@ -290,8 +291,8 @@ bool WrappedID3D12CommandQueue::Serialise_ExecuteCommandLists(SerialiserType &se
             ID3D12CommandList *cmd = m_Cmd.RerecordCmdList(cmdId);
             ResourceId rerecord = GetResID(cmd);
 #if ENABLED(VERBOSE_PARTIAL_REPLAY)
-            RDCDEBUG("Queue submit re-recorded replay of %llu, using %llu (%u -> %u <= %u)", cmdId,
-                     rerecord, eid, end, m_Cmd.m_LastEventID);
+            RDCDEBUG("Queue submit re-recorded replay of %s, using %s (%u -> %u <= %u)",
+                     ToStr(cmdId).c_str(), ToStr(rerecord).c_str(), eid, end, m_Cmd.m_LastEventID);
 #endif
             rerecordedCmds.push_back(Unwrap(cmd));
 
@@ -300,7 +301,7 @@ bool WrappedID3D12CommandQueue::Serialise_ExecuteCommandLists(SerialiserType &se
           else
           {
 #if ENABLED(VERBOSE_PARTIAL_REPLAY)
-            RDCDEBUG("Queue not submitting %llu", cmdId);
+            RDCDEBUG("Queue not submitting %s", ToStr(cmdId).c_str());
 #endif
           }
 
@@ -490,8 +491,8 @@ void WrappedID3D12CommandQueue::ExecuteCommandListsInternal(UINT NumCommandLists
         // only need to flush memory that could affect this submitted batch of work
         if(refdIDs.find(res->GetResourceID()) == refdIDs.end())
         {
-          RDCDEBUG("Map of memory %llu not referenced in this queue - not flushing",
-                   res->GetResourceID());
+          RDCDEBUG("Map of memory %s not referenced in this queue - not flushing",
+                   ToStr(res->GetResourceID()).c_str());
           continue;
         }
 
@@ -508,8 +509,8 @@ void WrappedID3D12CommandQueue::ExecuteCommandListsInternal(UINT NumCommandLists
 
         if(found)
         {
-          RDCLOG("Persistent map flush forced for %llu (%llu -> %llu)", res->GetResourceID(),
-                 (uint64_t)diffStart, (uint64_t)diffEnd);
+          RDCLOG("Persistent map flush forced for %s (%llu -> %llu)",
+                 ToStr(res->GetResourceID()).c_str(), (uint64_t)diffStart, (uint64_t)diffEnd);
 
           D3D12_RANGE range = {diffStart, diffEnd};
 
@@ -529,7 +530,7 @@ void WrappedID3D12CommandQueue::ExecuteCommandListsInternal(UINT NumCommandLists
         }
         else
         {
-          RDCDEBUG("Persistent map flush not needed for %llu", res->GetResourceID());
+          RDCDEBUG("Persistent map flush not needed for %s", ToStr(res->GetResourceID()).c_str());
         }
       }
 

renderdoc/driver/d3d12/d3d12_commands.cpp

@@ -1479,7 +1479,7 @@ ID3D12GraphicsCommandListX *D3D12CommandData::RerecordCmdList(ResourceId cmdid,
 
   if(it == m_RerecordCmds.end())
   {
-    RDCERR("Didn't generate re-record command for %llu", cmdid);
+    RDCERR("Didn't generate re-record command for %s", ToStr(cmdid).c_str());
     return NULL;
   }
 

renderdoc/driver/d3d12/d3d12_device.cpp

@@ -1294,8 +1294,9 @@ bool WrappedID3D12Device::Serialise_MapDataWrite(SerialiserType &ser, ID3D12Reso
 
       ID3D12Resource *uploadBuf = GetUploadBuffer(cmd.m_CurChunkOffset, rangeSize);
 
-      SetObjName(uploadBuf, StringFormat::Fmt("Map data write, %llu bytes for %llu/%u @ %llu",
-                                              rangeSize, origid, Subresource, cmd.m_CurChunkOffset));
+      SetObjName(uploadBuf,
+                 StringFormat::Fmt("Map data write, %llu bytes for %s/%u @ %llu", rangeSize,
+                                   ToStr(origid).c_str(), Subresource, cmd.m_CurChunkOffset));
 
       // during loading, fill out the buffer itself
       if(IsLoading(m_State))
@@ -2077,8 +2078,8 @@ bool WrappedID3D12Device::EndFrameCapture(void *dev, void *wnd)
 
       const rdcarray<D3D12ResourceRecord *> &cmdListRecords = q->GetCmdLists();
 
-      RDCDEBUG("Flushing %u command list records from queue %llu", (uint32_t)cmdListRecords.size(),
-               q->GetResourceID());
+      RDCDEBUG("Flushing %u command list records from queue %s", (uint32_t)cmdListRecords.size(),
+               ToStr(q->GetResourceID()).c_str());
 
       for(size_t i = 0; i < cmdListRecords.size(); i++)
       {
@@ -2088,8 +2089,9 @@ bool WrappedID3D12Device::EndFrameCapture(void *dev, void *wnd)
         // prevent complaints in release that prevSize is unused
         (void)prevSize;
 
-        RDCDEBUG("Adding %u chunks to file serialiser from command list %llu",
-                 (uint32_t)recordlist.size() - prevSize, cmdListRecords[i]->GetResourceID());
+        RDCDEBUG("Adding %u chunks to file serialiser from command list %s",
+                 (uint32_t)recordlist.size() - prevSize,
+                 ToStr(cmdListRecords[i]->GetResourceID()).c_str());
       }
 
       q->GetResourceRecord()->Insert(recordlist);
@@ -2657,7 +2659,7 @@ void WrappedID3D12Device::FreeRTV(D3D12_CPU_DESCRIPTOR_HANDLE handle)
   }
   else
   {
-    RDCERR("Unknown RTV %llu being freed", handle.ptr);
+    RDCERR("Unknown RTV %zu being freed", handle.ptr);
   }
 }
 

renderdoc/driver/d3d12/d3d12_device_wrap.cpp

@@ -56,7 +56,7 @@ bool WrappedID3D12Device::Serialise_CreateCommandQueue(SerialiserType &ser,
     }
     else
     {
-      SetObjName(ret, StringFormat::Fmt("Command Queue ID %llu", pCommandQueue));
+      SetObjName(ret, StringFormat::Fmt("Command Queue %s", ToStr(pCommandQueue).c_str()));
 
       ret = new WrappedID3D12CommandQueue(ret, this, m_State);
 
@@ -1305,8 +1305,8 @@ bool WrappedID3D12Device::Serialise_CreateCommittedResource(
       // smaller resources it's better to just leave them as upload and map into them
       if(desc.Width >= 1024 * 1024)
       {
-        RDCLOG("Remapping committed resource %llu from upload to default for efficient replay",
-               pResource);
+        RDCLOG("Remapping committed resource %s from upload to default for efficient replay",
+               ToStr(pResource).c_str());
         props.Type = D3D12_HEAP_TYPE_DEFAULT;
         m_UploadResourceIds.insert(pResource);
       }
@@ -1338,8 +1338,8 @@ bool WrappedID3D12Device::Serialise_CreateCommittedResource(
     }
     else
     {
-      SetObjName(ret, StringFormat::Fmt("Committed Resource %s ID %llu",
-                                        ToStr(desc.Dimension).c_str(), pResource));
+      SetObjName(ret, StringFormat::Fmt("Committed Resource %s %s", ToStr(desc.Dimension).c_str(),
+                                        ToStr(pResource).c_str()));
 
       ret = new WrappedID3D12Resource1(ret, this);
 
@@ -1616,8 +1616,8 @@ bool WrappedID3D12Device::Serialise_CreatePlacedResource(
     }
     else
     {
-      SetObjName(ret, StringFormat::Fmt("Placed Resource %s ID %llu",
-                                        ToStr(Descriptor.Dimension).c_str(), pResource));
+      SetObjName(ret, StringFormat::Fmt("Placed Resource %s %s", ToStr(Descriptor.Dimension).c_str(),
+                                        ToStr(pResource).c_str()));
 
       ret = new WrappedID3D12Resource1(ret, this);
 
@@ -2376,8 +2376,8 @@ bool WrappedID3D12Device::Serialise_OpenSharedHandle(SerialiserType &ser, HANDLE
       }
       else
       {
-        SetObjName(ret, StringFormat::Fmt("Shared Resource %s ID %llu",
-                                          ToStr(desc.Dimension).c_str(), resourceId));
+        SetObjName(ret, StringFormat::Fmt("Shared Resource %s %s", ToStr(desc.Dimension).c_str(),
+                                          ToStr(resourceId).c_str()));
 
         ret = new WrappedID3D12Resource1(ret, this);
 

renderdoc/driver/d3d12/d3d12_device_wrap4.cpp

@@ -225,8 +225,8 @@ bool WrappedID3D12Device::Serialise_CreateCommittedResource1(
       // smaller resources it's better to just leave them as upload and map into them
       if(desc.Width >= 1024 * 1024)
       {
-        RDCLOG("Remapping committed resource %llu from upload to default for efficient replay",
-               pResource);
+        RDCLOG("Remapping committed resource %s from upload to default for efficient replay",
+               ToStr(pResource).c_str());
         props.Type = D3D12_HEAP_TYPE_DEFAULT;
         m_UploadResourceIds.insert(pResource);
       }
@@ -262,8 +262,8 @@ bool WrappedID3D12Device::Serialise_CreateCommittedResource1(
     }
     else
     {
-      SetObjName(ret, StringFormat::Fmt("Committed Resource %s ID %llu",
-                                        ToStr(desc.Dimension).c_str(), pResource));
+      SetObjName(ret, StringFormat::Fmt("Committed Resource %s ID %s",
+                                        ToStr(desc.Dimension).c_str(), ToStr(pResource).c_str()));
 
       ret = new WrappedID3D12Resource1(ret, this);
 

renderdoc/driver/d3d12/d3d12_replay.cpp

@@ -2682,7 +2682,7 @@ void D3D12Replay::GetBufferData(ResourceId buff, uint64_t offset, uint64_t lengt
 
   if(it == m_pDevice->GetResourceList().end())
   {
-    RDCERR("Getting buffer data for unknown buffer %llu!", buff);
+    RDCERR("Getting buffer data for unknown buffer %s!", ToStr(buff).c_str());
     return;
   }
 
@@ -2704,7 +2704,7 @@ void D3D12Replay::FillCBufferVariables(ResourceId pipeline, ResourceId shader, r
 
   if(!WrappedID3D12Shader::IsAlloc(res))
   {
-    RDCERR("Shader ID %llu does not correspond to a known fake shader", shader);
+    RDCERR("Shader ID %s does not correspond to a known fake shader", ToStr(shader).c_str());
     return;
   }
 
@@ -2999,7 +2999,7 @@ void D3D12Replay::GetTextureData(ResourceId tex, const Subresource &sub,
 
   if(resource == NULL)
   {
-    RDCERR("Trying to get texture data for unknown ID %llu!", tex);
+    RDCERR("Trying to get texture data for unknown ID %s!", ToStr(tex).c_str());
     return;
   }
 

renderdoc/driver/d3d12/d3d12_state.cpp

@@ -200,8 +200,8 @@ void D3D12RenderState::ApplyComputeRootElements(ID3D12GraphicsCommandListX *cmd)
     }
     else
     {
-      RDCDEBUG("Skipping setting possibly stale compute root table referring to heap %llu",
-               compute.sigelems[i].id);
+      RDCDEBUG("Skipping setting possibly stale compute root table referring to heap %s",
+               ToStr(compute.sigelems[i].id).c_str());
     }
   }
 }
@@ -218,8 +218,8 @@ void D3D12RenderState::ApplyGraphicsRootElements(ID3D12GraphicsCommandListX *cmd
     }
     else
     {
-      RDCDEBUG("Skipping setting possibly stale graphics root table referring to heap %llu",
-               graphics.sigelems[i].id);
+      RDCDEBUG("Skipping setting possibly stale graphics root table referring to heap %s",
+               ToStr(graphics.sigelems[i].id).c_str());
     }
   }
 }

renderdoc/driver/vulkan/vk_manager.cpp

@@ -679,7 +679,7 @@ void VulkanResourceManager::ApplyBarriers(uint32_t queueFamilyIndex,
     ResourceId id = states[ti].first;
     ImageRegionState &t = states[ti].second;
 
-    TRDBG("Applying barrier to %llu", GetOriginalID(id));
+    TRDBG("Applying barrier to %s", ToStr(GetOriginalID(id)).c_str());
 
     auto stit = layouts.find(id);
 

renderdoc/driver/vulkan/wrappers/vk_cmd_funcs.cpp

@@ -756,8 +756,9 @@ bool WrappedVulkan::Serialise_vkBeginCommandBuffer(SerialiserType &ser, VkComman
           if(it->baseEvent <= m_LastEventID && m_LastEventID < (it->baseEvent + length))
           {
 #if ENABLED(VERBOSE_PARTIAL_REPLAY)
-            RDCDEBUG("vkBegin - partial detected %u < %u < %u, %llu -> %llu", it->baseEvent,
-                     m_LastEventID, it->baseEvent + length, m_LastCmdBufferID, BakedCommandBuffer);
+            RDCDEBUG("vkBegin - partial detected %u < %u < %u, %s -> %s", it->baseEvent,
+                     m_LastEventID, it->baseEvent + length, ToStr(m_LastCmdBufferID).c_str(),
+                     ToStr(BakedCommandBuffer).c_str());
 #endif
 
             m_Partial[p].partialParent = BakedCommandBuffer;
@@ -773,8 +774,9 @@ bool WrappedVulkan::Serialise_vkBeginCommandBuffer(SerialiserType &ser, VkComman
           else if(it->baseEvent <= m_LastEventID)
           {
 #if ENABLED(VERBOSE_PARTIAL_REPLAY)
-            RDCDEBUG("vkBegin - full re-record detected %u < %u <= %u, %llu -> %llu", it->baseEvent,
-                     it->baseEvent + length, m_LastEventID, m_LastCmdBufferID, BakedCommandBuffer);
+            RDCDEBUG("vkBegin - full re-record detected %u < %u <= %u, %s -> %s", it->baseEvent,
+                     it->baseEvent + length, m_LastEventID, ToStr(m_LastCmdBufferID).c_str(),
+                     ToStr(BakedCommandBuffer).c_str());
 #endif
 
             // this submission is completely within the range, so it should still be re-recorded
@@ -801,8 +803,8 @@ bool WrappedVulkan::Serialise_vkBeginCommandBuffer(SerialiserType &ser, VkComman
         }
 
 #if ENABLED(VERBOSE_PARTIAL_REPLAY)
-        RDCDEBUG("vkBegin - re-recording %llu -> %llu into %llu", m_LastCmdBufferID,
-                 BakedCommandBuffer, GetResID(cmd));
+        RDCDEBUG("vkBegin - re-recording %s -> %s into %s", ToStr(m_LastCmdBufferID).c_str(),
+                 ToStr(BakedCommandBuffer).c_str(), ToStr(GetResID(cmd)).c_str());
 #endif
 
         // we store under both baked and non baked ID.
@@ -1008,8 +1010,9 @@ bool WrappedVulkan::Serialise_vkEndCommandBuffer(SerialiserType &ser, VkCommandB
         commandBuffer = RerecordCmdBuf(BakedCommandBuffer);
 
 #if ENABLED(VERBOSE_PARTIAL_REPLAY)
-        RDCDEBUG("Ending re-recorded command buffer for %llu baked to %llu as %llu", CommandBuffer,
-                 BakedCommandBuffer, GetResID(commandBuffer));
+        RDCDEBUG("Ending re-recorded command buffer for %s baked to %s as %s",
+                 ToStr(CommandBuffer).c_str(), ToStr(BakedCommandBuffer).c_str(),
+                 ToStr(GetResID(commandBuffer)).c_str());
 #endif
 
         if(m_Partial[Primary].partialParent == BakedCommandBuffer &&
@@ -3514,8 +3517,8 @@ bool WrappedVulkan::Serialise_vkCmdExecuteCommands(SerialiserType &ser, VkComman
         if(m_Partial[Primary].partialParent != m_LastCmdBufferID)
         {
 #if ENABLED(VERBOSE_PARTIAL_REPLAY)
-          RDCDEBUG("Fully re-recording non-partial execute in command buffer %llu for %llu",
-                   GetResID(commandBuffer), m_LastCmdBufferID);
+          RDCDEBUG("Fully re-recording non-partial execute in command buffer %s for %s",
+                   ToStr(GetResID(commandBuffer)).c_str(), ToStr(m_LastCmdBufferID).c_str());
 #endif
           fullRecord = true;
         }
@@ -3580,8 +3583,8 @@ bool WrappedVulkan::Serialise_vkCmdExecuteCommands(SerialiserType &ser, VkComman
               VkCommandBuffer cmd = RerecordCmdBuf(cmdid);
               ResourceId rerecord = GetResID(cmd);
 #if ENABLED(VERBOSE_PARTIAL_REPLAY)
-              RDCDEBUG("ExecuteCommands re-recorded replay of %llu, using %llu (%u -> %u <= %u)",
-                       cmdid, rerecord, eid, end, m_LastEventID);
+              RDCDEBUG("ExecuteCommands re-recorded replay of %s, using %s (%u -> %u <= %u)",
+                       ToStr(cmdid).c_str(), ToStr(rerecord).c_str(), eid, end, m_LastEventID);
 #endif
               rerecordedCmds.push_back(Unwrap(cmd));
 
@@ -3592,7 +3595,7 @@ bool WrappedVulkan::Serialise_vkCmdExecuteCommands(SerialiserType &ser, VkComman
             else
             {
 #if ENABLED(VERBOSE_PARTIAL_REPLAY)
-              RDCDEBUG("not executing %llu", cmdid);
+              RDCDEBUG("not executing %s", ToStr(cmdid).c_str());
 #endif
             }
 
@@ -3602,7 +3605,8 @@ bool WrappedVulkan::Serialise_vkCmdExecuteCommands(SerialiserType &ser, VkComman
           }
 
 #if ENABLED(VERBOSE_PARTIAL_REPLAY)
-          RDCDEBUG("executing %zu commands in %llu", rerecordedCmds.size(), GetResID(commandBuffer));
+          RDCDEBUG("executing %zu commands in %s", rerecordedCmds.size(),
+                   ToStr(GetResID(commandBuffer)).c_str());
 #endif
 
           if(!rerecordedCmds.empty())