Avoid using '#' format spec for X hex numbers.

Avoid using '#' format spec for X (uppercase) hex numbers, as it
results in output like "0XABCDEF" instead of "0xABCDEF".

src/xenia/gpu/command_processor.cc

@@ -737,7 +737,7 @@ bool CommandProcessor::ExecutePacketType3(RingBuffer* reader, uint32_t packet) {
     }
 
     default:
-      XELOGGPU("Unimplemented GPU OPCODE: {:#02X}\t\tCOUNT: {}\n", opcode,
+      XELOGGPU("Unimplemented GPU OPCODE: 0x{:02X}\t\tCOUNT: {}\n", opcode,
                count);
       assert_always();
       reader->AdvanceRead(count * sizeof(uint32_t));

src/xenia/gpu/d3d12/d3d12_command_processor.cc

@@ -1488,7 +1488,7 @@ bool D3D12CommandProcessor::IssueDraw(PrimitiveType primitive_type,
     if (!shared_memory_->RequestRange(vfetch_constant.address << 2,
                                       vfetch_constant.size << 2)) {
       XELOGE(
-          "Failed to request vertex buffer at {:#08X} (size {}) in the shared "
+          "Failed to request vertex buffer at 0x{:08X} (size {}) in the shared "
           "memory",
           vfetch_constant.address << 2, vfetch_constant.size << 2);
       return false;
@@ -1590,7 +1590,7 @@ bool D3D12CommandProcessor::IssueDraw(PrimitiveType primitive_type,
     if (!shared_memory_->RequestRange(memexport_range.base_address_dwords << 2,
                                       memexport_range.size_dwords << 2)) {
       XELOGE(
-          "Failed to request memexport stream at {:#08X} (size {}) in the "
+          "Failed to request memexport stream at 0x{:08X} (size {}) in the "
           "shared memory",
           memexport_range.base_address_dwords << 2,
           memexport_range.size_dwords << 2);
@@ -1636,8 +1636,8 @@ bool D3D12CommandProcessor::IssueDraw(PrimitiveType primitive_type,
       uint32_t index_buffer_size = index_buffer_info->count * index_size;
       if (!shared_memory_->RequestRange(index_base, index_buffer_size)) {
         XELOGE(
-            "Failed to request index buffer at {:#08X} (size {}) in the shared "
-            "memory",
+            "Failed to request index buffer at 0x{:08X} (size {}) in the "
+            "shared memory",
             index_base, index_buffer_size);
         return false;
       }

src/xenia/gpu/d3d12/render_target_cache.cc

@@ -1340,7 +1340,7 @@ bool RenderTargetCache::ResolveCopy(SharedMemory* shared_memory,
   bool dest_swap = !is_depth && rb_copy_dest_info.copy_dest_swap;
 
   XELOGGPU(
-      "Resolve: Copying samples {} to {:#08X} ({}x{}, {}D), destination Z {}, "
+      "Resolve: Copying samples {} to 0x{:08X} ({}x{}, {}D), destination Z {}, "
       "destination format {}, exponent bias {}, red and blue {}swapped",
       uint32_t(sample_select), dest_address, dest_pitch, dest_height,
       rb_copy_dest_info.copy_dest_array ? '3' : '2', dest_z,

src/xenia/gpu/d3d12/texture_cache.cc

@@ -2178,7 +2178,7 @@ void TextureCache::BindingInfoFromFetchConstant(
 void TextureCache::LogTextureKeyAction(TextureKey key, const char* action) {
   XELOGGPU(
       "{} {} {}{}x{}x{} {} {} texture with {} {}packed mip level{}, "
-      "base at {:#08X}, mips at {:#08X}",
+      "base at 0x{:08X}, mips at 0x{:08X}",
       action, key.tiled ? "tiled" : "linear",
       key.scaled_resolve ? "2x-scaled " : "", key.width, key.height, key.depth,
       dimension_names_[uint32_t(key.dimension)],
@@ -2191,7 +2191,7 @@ void TextureCache::LogTextureAction(const Texture* texture,
                                     const char* action) {
   XELOGGPU(
       "{} {} {}{}x{}x{} {} {} texture with {} {}packed mip level{}, "
-      "base at {:#08X} (size {}), mips at {:#08X} (size {})",
+      "base at 0x{:08X} (size {}), mips at 0x{:08X} (size {})",
       action, texture->key.tiled ? "tiled" : "linear",
       texture->key.scaled_resolve ? "2x-scaled " : "", texture->key.width,
       texture->key.height, texture->key.depth,

src/xenia/gpu/vulkan/render_cache.cc

@@ -232,7 +232,7 @@ VkResult CachedTileView::Initialize(VkCommandBuffer command_buffer) {
 
   device_->DbgSetObjectName(
       reinterpret_cast<uint64_t>(image), VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT,
-      fmt::format("RT(d): {:#08X} {:#08X}({}) {:#08X}({}) {} {} {}",
+      fmt::format("RT(d): 0x{:08X} 0x{:08X}({}) 0x{:08X}({}) {} {} {}",
                   uint32_t(key.tile_offset), uint32_t(key.tile_width),
                   uint32_t(key.tile_width), uint32_t(key.tile_height),
                   uint32_t(key.tile_height), uint32_t(key.color_or_depth),

src/xenia/gpu/vulkan/texture_cache.cc

@@ -522,7 +522,7 @@ TextureCache::Texture* TextureCache::DemandResolveTexture(
       reinterpret_cast<uint64_t>(texture->image),
       VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT,
       fmt::format(
-          "RT: {:#08X} - {:#08X} ({}, {})", texture_info.memory.base_address,
+          "RT: 0x{:08X} - 0x{:08X} ({}, {})", texture_info.memory.base_address,
           texture_info.memory.base_address + texture_info.memory.base_size,
           texture_info.format_info()->name,
           get_dimension_name(texture_info.dimension)));
@@ -605,7 +605,7 @@ TextureCache::Texture* TextureCache::Demand(const TextureInfo& texture_info,
       reinterpret_cast<uint64_t>(texture->image),
       VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT,
       fmt::format(
-          "T: {:#08X} - {:#08X} ({}, {})", texture_info.memory.base_address,
+          "T: 0x{:08X} - 0x{:08X} ({}, {})", texture_info.memory.base_address,
           texture_info.memory.base_address + texture_info.memory.base_size,
           texture_info.format_info()->name,
           get_dimension_name(texture_info.dimension)));
@@ -1068,9 +1068,9 @@ bool TextureCache::UploadTexture(VkCommandBuffer command_buffer,
   size_t unpack_length = ComputeTextureStorage(src);
 
   XELOGGPU(
-      "Uploading texture @ {:#08X}/{:#08X} ({}x{}x{}, format: {}, dim: {}, "
+      "Uploading texture @ 0x{:08X}/0x{:08X} ({}x{}x{}, format: {}, dim: {}, "
       "levels: {} ({}-{}), stacked: {}, pitch: {}, tiled: {}, packed mips: {}, "
-      "unpack length: {:#X})",
+      "unpack length: 0x{:X})",
       src.memory.base_address, src.memory.mip_address, src.width + 1,
       src.height + 1, src.depth + 1, src.format_info()->name,
       get_dimension_name(src.dimension), src.mip_levels(), src.mip_min_level,
@@ -1097,7 +1097,7 @@ bool TextureCache::UploadTexture(VkCommandBuffer command_buffer,
     if (!staging_buffer_.CanAcquire(unpack_length)) {
       // The staging buffer isn't big enough to hold this texture.
       XELOGE(
-          "TextureCache staging buffer is too small! (uploading {:#X} bytes)",
+          "TextureCache staging buffer is too small! (uploading 0x{:X} bytes)",
           unpack_length);
       assert_always();
       return false;
@@ -1123,7 +1123,7 @@ bool TextureCache::UploadTexture(VkCommandBuffer command_buffer,
   }
 
   if (!valid) {
-    XELOGW("Warning: Texture @ {:#08X} is blank!", src.memory.base_address);
+    XELOGW("Warning: Texture @ 0x{:08X} is blank!", src.memory.base_address);
   }
 
   // Upload texture into GPU memory.
@@ -1147,7 +1147,7 @@ bool TextureCache::UploadTexture(VkCommandBuffer command_buffer,
     copy_regions[region].imageOffset = {0, 0, 0};
 
     /*
-    XELOGGPU("Mip {} {}x{}x{} @ {:#X}", mip,
+    XELOGGPU("Mip {} {}x{}x{} @ 0x{:X}", mip,
              copy_regions[region].imageExtent.width,
              copy_regions[region].imageExtent.height,
              copy_regions[region].imageExtent.depth, unpack_offset);

src/xenia/gpu/vulkan/vulkan_command_processor.cc

@@ -1121,7 +1121,7 @@ bool VulkanCommandProcessor::IssueCopy() {
                                         : static_cast<uint32_t>(depth_format);
   VkFilter filter = is_color_source ? VK_FILTER_LINEAR : VK_FILTER_NEAREST;
 
-  XELOGGPU("Resolve RT {:08X} {:08X}({}) -> {:#08X} ({}x{}, format: {})",
+  XELOGGPU("Resolve RT {:08X} {:08X}({}) -> 0x{:08X} ({}x{}, format: {})",
            edram_base, surface_pitch, surface_pitch, copy_dest_base,
            copy_dest_pitch, copy_dest_height, texture_info.format_info()->name);
   switch (copy_command) {