[dxvk] Added debug tracing

src/dxvk/dxvk_adapter.cpp

@@ -13,6 +13,7 @@ namespace dxvk {
   : m_instance      (instance),
     m_vki           (instance->vki()),
     m_handle        (handle) {
+    TRACE(this, instance, handle);
     uint32_t numQueueFamilies = 0;
     m_vki->vkGetPhysicalDeviceQueueFamilyProperties(
       m_handle, &numQueueFamilies, nullptr);
@@ -24,7 +25,7 @@ namespace dxvk {
   
   
   DxvkAdapter::~DxvkAdapter() {
-    
+    TRACE(this);
   }
   
   
@@ -94,6 +95,8 @@ namespace dxvk {
   
   
   Rc<DxvkDevice> DxvkAdapter::createDevice() {
+    TRACE(this);
+    
     auto enabledExtensions = this->enableExtensions();
     auto enabledFeatures   = this->enableFeatures();
     

src/dxvk/dxvk_cmdlist.cpp

@@ -6,6 +6,8 @@ namespace dxvk {
     const Rc<vk::DeviceFn>& vkd,
           uint32_t          queueFamily)
   : m_vkd(vkd) {
+    TRACE(this, queueFamily);
+    
     VkCommandPoolCreateInfo poolInfo;
     poolInfo.sType            = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO;
     poolInfo.pNext            = nullptr;
@@ -28,6 +30,7 @@ namespace dxvk {
   
   
   DxvkCommandList::~DxvkCommandList() {
+    TRACE(this);
     m_resources.reset();
     
     m_vkd->vkDestroyCommandPool(
@@ -36,6 +39,8 @@ namespace dxvk {
   
   
   void DxvkCommandList::beginRecording() {
+    TRACE(this);
+    
     VkCommandBufferBeginInfo info;
     info.sType            = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;
     info.pNext            = nullptr;
@@ -51,17 +56,21 @@ namespace dxvk {
   
   
   void DxvkCommandList::endRecording() {
+    TRACE(this);
+    
     if (m_vkd->vkEndCommandBuffer(m_buffer) != VK_SUCCESS)
       throw DxvkError("DxvkCommandList::endRecording: Failed to record command buffer");
   }
   
   
   void DxvkCommandList::trackResource(const Rc<DxvkResource>& rc) {
+    TRACE(this, rc);
     m_resources.trackResource(rc);
   }
   
   
   void DxvkCommandList::reset() {
+    TRACE(this);
     m_resources.reset();
   }
   

src/dxvk/dxvk_context.cpp

@@ -4,22 +4,26 @@
 namespace dxvk {
   
   DxvkContext::DxvkContext(const Rc<vk::DeviceFn>& vkd)
-  : m_vkd(vkd) { }
+  : m_vkd(vkd) {
+    TRACE(this);
+  }
   
   
   DxvkContext::~DxvkContext() {
-    
+    TRACE(this);
   }
   
   
   void DxvkContext::beginRecording(
     const Rc<DxvkCommandList>& cmdList) {
+    TRACE(this, cmdList);
     m_commandList = cmdList;
     m_commandList->beginRecording();
   }
   
   
   bool DxvkContext::endRecording() {
+    TRACE(this);
     m_commandList->endRecording();
     m_commandList = nullptr;
     return true;
@@ -28,6 +32,8 @@ namespace dxvk {
   
   void DxvkContext::setFramebuffer(
     const Rc<DxvkFramebuffer>& fb) {
+    TRACE(this, fb);
+    
     const DxvkFramebufferSize fbSize = fb->size();
     // TODO implement properly
     VkRect2D renderArea;

src/dxvk/dxvk_device.cpp

@@ -10,6 +10,8 @@ namespace dxvk {
     m_vkd           (vkd),
     m_memory        (adapter, vkd),
     m_renderPassPool(vkd) {
+    TRACE(this, adapter);
+    
     m_vkd->vkGetDeviceQueue(m_vkd->device(),
       m_adapter->graphicsQueueFamily(), 0,
       &m_graphicsQueue);
@@ -20,6 +22,7 @@ namespace dxvk {
   
   
   DxvkDevice::~DxvkDevice() {
+    TRACE(this);
     m_vkd->vkDeviceWaitIdle(m_vkd->device());
     m_vkd->vkDestroyDevice(m_vkd->device(), nullptr);
   }
@@ -74,6 +77,8 @@ namespace dxvk {
     const Rc<DxvkCommandList>&      commandList,
     const Rc<DxvkSemaphore>&        waitSync,
     const Rc<DxvkSemaphore>&        wakeSync) {
+    TRACE(this, commandList, waitSync, wakeSync);
+    
     Rc<DxvkFence> fence = new DxvkFence(m_vkd);
     
     VkCommandBuffer commandBuffer = commandList->handle();
@@ -107,11 +112,15 @@ namespace dxvk {
     if (m_vkd->vkQueueSubmit(m_graphicsQueue, 1, &info, fence->handle()) != VK_SUCCESS)
       throw DxvkError("DxvkDevice::submitCommandList: Command submission failed");
     
+    // TODO Store fence + command list pairs in a ring buffer
+    fence->wait(std::numeric_limits<uint64_t>::max());
+    commandList->reset();
     return fence;
   }
   
   
   void DxvkDevice::waitForIdle() const {
+    TRACE(this);
     if (m_vkd->vkDeviceWaitIdle(m_vkd->device()) != VK_SUCCESS)
       throw DxvkError("DxvkDevice::waitForIdle: Operation failed");
   }

src/dxvk/dxvk_framebuffer.cpp

@@ -69,6 +69,7 @@ namespace dxvk {
     m_renderPass      (renderPass),
     m_renderTargets   (renderTargets),
     m_framebufferSize (renderTargets.getImageSize()) {
+    TRACE(this, renderPass);
     auto views = renderTargets.getAttachments();
     
     VkFramebufferCreateInfo info;
@@ -88,6 +89,7 @@ namespace dxvk {
   
   
   DxvkFramebuffer::~DxvkFramebuffer() {
+    TRACE(this);
     m_vkd->vkDestroyFramebuffer(
       m_vkd->device(), m_framebuffer, nullptr);
   }

src/dxvk/dxvk_image.cpp

@@ -15,10 +15,13 @@ namespace dxvk {
     const Rc<vk::DeviceFn>&     vkd,
     const DxvkImageCreateInfo&  info,
           VkImage               image)
-  : m_vkd(vkd), m_info(info), m_image(image) { }
+  : m_vkd(vkd), m_info(info), m_image(image) {
+    TRACE(this, image);
+  }
   
   
   DxvkImage::~DxvkImage() {
+    TRACE(this);
     // This is a bit of a hack to determine whether
     // the image is implementation-handled or not
     if (m_memory.memory() != VK_NULL_HANDLE)
@@ -31,6 +34,7 @@ namespace dxvk {
     const Rc<DxvkImage>&            image,
     const DxvkImageViewCreateInfo&  info)
   : m_vkd(vkd), m_image(image), m_info(info) {
+    TRACE(this, image);
     VkComponentMapping componentMapping;
     componentMapping.r = VK_COMPONENT_SWIZZLE_IDENTITY;
     componentMapping.g = VK_COMPONENT_SWIZZLE_IDENTITY;
@@ -60,7 +64,9 @@ namespace dxvk {
   
   
   DxvkImageView::~DxvkImageView() {
-    m_vkd->vkDestroyImageView(m_vkd->device(), m_view, nullptr);
+    TRACE(this);
+    m_vkd->vkDestroyImageView(
+      m_vkd->device(), m_view, nullptr);
   }
   
 }

src/dxvk/dxvk_include.h

@@ -1,5 +1,8 @@
 #pragma once
 
+#include "../util/log/log.h"
+#include "../util/log/log_debug.h"
+
 #include "../util/util_error.h"
 #include "../util/util_string.h"
 
@@ -8,3 +11,4 @@
 
 #include "./vulkan/dxvk_vulkan_extensions.h"
 #include "./vulkan/dxvk_vulkan_loader.h"
+#include "./vulkan/dxvk_vulkan_names.h"

src/dxvk/dxvk_instance.cpp

@@ -1,16 +1,16 @@
 #include "dxvk_instance.h"
-#include "dxvk_main.h"
 
 namespace dxvk {
   
   DxvkInstance::DxvkInstance()
   : m_vkl(new vk::LibraryFn()),
     m_vki(new vk::InstanceFn(this->createInstance())) {
-    
+    TRACE(this);
   }
   
   
   DxvkInstance::~DxvkInstance() {
+    TRACE(this);
     m_vki->vkDestroyInstance(
       m_vki->instance(), nullptr);
   }
@@ -36,6 +36,11 @@ namespace dxvk {
     auto enabledLayers     = this->getLayers();
     auto enabledExtensions = this->getExtensions(enabledLayers);
     
+    Logger::info("Enabled instance layers:");
+    this->logNameList(enabledLayers);
+    Logger::info("Enabled instance extensions:");
+    this->logNameList(enabledExtensions);
+    
     VkApplicationInfo appInfo;
     appInfo.sType                 = VK_STRUCTURE_TYPE_APPLICATION_INFO;
     appInfo.pNext                 = nullptr;
@@ -105,4 +110,10 @@ namespace dxvk {
     return extensionsEnabled;
   }
   
+  
+  void DxvkInstance::logNameList(const vk::NameList& names) {
+    for (uint32_t i = 0; i < names.count(); i++)
+      Logger::info(str::format("  ", names.name(i)));
+  }
+  
 }

src/dxvk/dxvk_instance.h

@@ -51,6 +51,8 @@ namespace dxvk {
     vk::NameList getLayers();
     vk::NameList getExtensions(const vk::NameList& layers);
     
+    void logNameList(const vk::NameList& names);
+    
   };
   
 }

src/dxvk/dxvk_memory.cpp

@@ -90,6 +90,7 @@ namespace dxvk {
   
   VkDeviceMemory DxvkMemoryAllocator::allocMemory(
     VkDeviceSize blockSize, uint32_t memoryType) {
+    TRACE(blockSize, memoryType);
     
     VkMemoryAllocateInfo info;
     info.sType            = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO;

src/dxvk/dxvk_renderpass.cpp

@@ -44,6 +44,7 @@ namespace dxvk {
           VkImageLayout         initialLayout,
           VkImageLayout         finalLayout)
   : m_vkd(vkd), m_format(fmt) {
+    TRACE(this, initialLayout, finalLayout);
     std::vector<VkAttachmentDescription> attachments;
     
     VkAttachmentReference                                 depthRef;
@@ -127,17 +128,20 @@ namespace dxvk {
   
   
   DxvkRenderPass::~DxvkRenderPass() {
+    TRACE(this);
     m_vkd->vkDestroyRenderPass(
       m_vkd->device(), m_renderPass, nullptr);
   }
   
   
   DxvkRenderPassPool::DxvkRenderPassPool(const Rc<vk::DeviceFn>& vkd)
-  : m_vkd(vkd) { }
+  : m_vkd(vkd) {
+    TRACE(this);
+  }
   
   
   DxvkRenderPassPool::~DxvkRenderPassPool() {
-    
+    TRACE(this);
   }
   
   

src/dxvk/dxvk_surface.cpp

@@ -13,11 +13,12 @@ namespace dxvk {
     m_handle          (createSurface(instance, window)),
     m_surfaceFormats  (getSurfaceFormats()),
     m_presentModes    (getPresentModes()) {
-    
+    TRACE(this, adapter, instance, window);
   }
   
   
   DxvkSurface::~DxvkSurface() {
+    TRACE(this);
     m_vki->vkDestroySurfaceKHR(
       m_vki->instance(), m_handle, nullptr);
   }

src/dxvk/dxvk_swapchain.cpp

@@ -17,11 +17,13 @@ namespace dxvk {
     m_surface   (surface),
     m_queue     (queue),
     m_properties(properties) {
+    TRACE(this, device, surface, queue);
     this->recreateSwapchain();
   }
   
   
   DxvkSwapchain::~DxvkSwapchain() {
+    TRACE(this);
     m_device->waitForIdle();
     m_vkd->vkDestroySwapchainKHR(
       m_vkd->device(), m_handle, nullptr);
@@ -30,6 +32,8 @@ namespace dxvk {
   
   Rc<DxvkFramebuffer> DxvkSwapchain::getFramebuffer(
     const Rc<DxvkSemaphore>& wakeSync) {
+    TRACE(this, wakeSync);
+    
     VkResult status = this->acquireNextImage(wakeSync);
     
     if (status == VK_ERROR_OUT_OF_DATE_KHR) {
@@ -46,6 +50,8 @@ namespace dxvk {
   
   
   void DxvkSwapchain::present(const Rc<DxvkSemaphore>& waitSync) {
+    TRACE(this, waitSync);
+    
     const VkSemaphore waitSemaphore = waitSync->handle();
     
     VkPresentInfoKHR info;
@@ -69,6 +75,7 @@ namespace dxvk {
   
   void DxvkSwapchain::changeProperties(
     const DxvkSwapchainProperties& props) {
+    TRACE(this);
     m_properties = props;
     this->recreateSwapchain();
   }
@@ -86,6 +93,7 @@ namespace dxvk {
   
   
   void DxvkSwapchain::recreateSwapchain() {
+    TRACE(this);
     VkSwapchainKHR oldSwapchain = m_handle;
     
     // Wait until we can be certain that none of our

src/dxvk/dxvk_sync.cpp

@@ -5,6 +5,8 @@ namespace dxvk {
   DxvkSemaphore::DxvkSemaphore(
     const Rc<vk::DeviceFn>& vkd)
   : m_vkd(vkd) {
+    TRACE(this);
+    
     VkSemaphoreCreateInfo info;
     info.sType = VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO;
     info.pNext = nullptr;
@@ -16,6 +18,7 @@ namespace dxvk {
   
   
   DxvkSemaphore::~DxvkSemaphore() {
+    TRACE(this);
     m_vkd->vkDestroySemaphore(
       m_vkd->device(), m_semaphore, nullptr);
   }
@@ -23,6 +26,8 @@ namespace dxvk {
   
   DxvkFence::DxvkFence(const Rc<vk::DeviceFn>& vkd)
   : m_vkd(vkd) {
+    TRACE(this);
+    
     VkFenceCreateInfo info;
     info.sType = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO;
     info.pNext = nullptr;
@@ -34,12 +39,15 @@ namespace dxvk {
   
   
   DxvkFence::~DxvkFence() {
+    TRACE(this);
     m_vkd->vkDestroyFence(
       m_vkd->device(), m_fence, nullptr);
   }
   
   
   bool DxvkFence::wait(uint64_t timeout) const {
+    TRACE(this, timeout);
+    
     VkResult status = m_vkd->vkWaitForFences(
       m_vkd->device(), 1, &m_fence, VK_FALSE, timeout);
     
@@ -50,6 +58,7 @@ namespace dxvk {
   
   
   void DxvkFence::reset() {
+    TRACE(this);
     if (m_vkd->vkResetFences(m_vkd->device(), 1, &m_fence) != VK_SUCCESS)
       throw DxvkError("DxvkFence::reset: Failed to reset fence");
   }

src/dxvk/meson.build

@@ -18,6 +18,7 @@ dxvk_src = files([
   
   'vulkan/dxvk_vulkan_extensions.cpp',
   'vulkan/dxvk_vulkan_loader.cpp',
+  'vulkan/dxvk_vulkan_names.cpp',
 ])
 
 thread_dep = dependency('threads')

src/dxvk/vulkan/dxvk_vulkan_names.cpp

@@ -0,0 +1,333 @@
+#include "dxvk_vulkan_names.h"
+    
+std::ostream& operator << (std::ostream& os, VkPipelineCacheHeaderVersion e) {
+  switch (e) {
+    ENUM_NAME(VK_PIPELINE_CACHE_HEADER_VERSION_ONE);
+    ENUM_DEFAULT(e);
+  }
+  return os;
+}
+
+
+std::ostream& operator << (std::ostream& os, VkResult e) {
+  switch (e) {
+    ENUM_NAME(VK_SUCCESS);
+    ENUM_NAME(VK_NOT_READY);
+    ENUM_NAME(VK_TIMEOUT);
+    ENUM_NAME(VK_EVENT_SET);
+    ENUM_NAME(VK_EVENT_RESET);
+    ENUM_NAME(VK_INCOMPLETE);
+    ENUM_NAME(VK_ERROR_OUT_OF_HOST_MEMORY);
+    ENUM_NAME(VK_ERROR_OUT_OF_DEVICE_MEMORY);
+    ENUM_NAME(VK_ERROR_INITIALIZATION_FAILED);
+    ENUM_NAME(VK_ERROR_DEVICE_LOST);
+    ENUM_NAME(VK_ERROR_MEMORY_MAP_FAILED);
+    ENUM_NAME(VK_ERROR_LAYER_NOT_PRESENT);
+    ENUM_NAME(VK_ERROR_EXTENSION_NOT_PRESENT);
+    ENUM_NAME(VK_ERROR_FEATURE_NOT_PRESENT);
+    ENUM_NAME(VK_ERROR_INCOMPATIBLE_DRIVER);
+    ENUM_NAME(VK_ERROR_TOO_MANY_OBJECTS);
+    ENUM_NAME(VK_ERROR_FORMAT_NOT_SUPPORTED);
+    ENUM_NAME(VK_ERROR_FRAGMENTED_POOL);
+    ENUM_NAME(VK_ERROR_SURFACE_LOST_KHR);
+    ENUM_NAME(VK_ERROR_NATIVE_WINDOW_IN_USE_KHR);
+    ENUM_NAME(VK_SUBOPTIMAL_KHR);
+    ENUM_NAME(VK_ERROR_OUT_OF_DATE_KHR);
+    ENUM_NAME(VK_ERROR_INCOMPATIBLE_DISPLAY_KHR);
+    ENUM_NAME(VK_ERROR_VALIDATION_FAILED_EXT);
+    ENUM_NAME(VK_ERROR_INVALID_SHADER_NV);
+    ENUM_NAME(VK_ERROR_OUT_OF_POOL_MEMORY_KHR);
+    ENUM_NAME(VK_ERROR_INVALID_EXTERNAL_HANDLE_KHR);
+    ENUM_DEFAULT(e);
+  }
+  return os;
+}
+
+
+std::ostream& operator << (std::ostream& os, VkFormat e) {
+  switch (e) {
+    ENUM_NAME(VK_FORMAT_UNDEFINED);
+    ENUM_NAME(VK_FORMAT_R4G4_UNORM_PACK8);
+    ENUM_NAME(VK_FORMAT_R4G4B4A4_UNORM_PACK16);
+    ENUM_NAME(VK_FORMAT_B4G4R4A4_UNORM_PACK16);
+    ENUM_NAME(VK_FORMAT_R5G6B5_UNORM_PACK16);
+    ENUM_NAME(VK_FORMAT_B5G6R5_UNORM_PACK16);
+    ENUM_NAME(VK_FORMAT_R5G5B5A1_UNORM_PACK16);
+    ENUM_NAME(VK_FORMAT_B5G5R5A1_UNORM_PACK16);
+    ENUM_NAME(VK_FORMAT_A1R5G5B5_UNORM_PACK16);
+    ENUM_NAME(VK_FORMAT_R8_UNORM);
+    ENUM_NAME(VK_FORMAT_R8_SNORM);
+    ENUM_NAME(VK_FORMAT_R8_USCALED);
+    ENUM_NAME(VK_FORMAT_R8_SSCALED);
+    ENUM_NAME(VK_FORMAT_R8_UINT);
+    ENUM_NAME(VK_FORMAT_R8_SINT);
+    ENUM_NAME(VK_FORMAT_R8_SRGB);
+    ENUM_NAME(VK_FORMAT_R8G8_UNORM);
+    ENUM_NAME(VK_FORMAT_R8G8_SNORM);
+    ENUM_NAME(VK_FORMAT_R8G8_USCALED);
+    ENUM_NAME(VK_FORMAT_R8G8_SSCALED);
+    ENUM_NAME(VK_FORMAT_R8G8_UINT);
+    ENUM_NAME(VK_FORMAT_R8G8_SINT);
+    ENUM_NAME(VK_FORMAT_R8G8_SRGB);
+    ENUM_NAME(VK_FORMAT_R8G8B8_UNORM);
+    ENUM_NAME(VK_FORMAT_R8G8B8_SNORM);
+    ENUM_NAME(VK_FORMAT_R8G8B8_USCALED);
+    ENUM_NAME(VK_FORMAT_R8G8B8_SSCALED);
+    ENUM_NAME(VK_FORMAT_R8G8B8_UINT);
+    ENUM_NAME(VK_FORMAT_R8G8B8_SINT);
+    ENUM_NAME(VK_FORMAT_R8G8B8_SRGB);
+    ENUM_NAME(VK_FORMAT_B8G8R8_UNORM);
+    ENUM_NAME(VK_FORMAT_B8G8R8_SNORM);
+    ENUM_NAME(VK_FORMAT_B8G8R8_USCALED);
+    ENUM_NAME(VK_FORMAT_B8G8R8_SSCALED);
+    ENUM_NAME(VK_FORMAT_B8G8R8_UINT);
+    ENUM_NAME(VK_FORMAT_B8G8R8_SINT);
+    ENUM_NAME(VK_FORMAT_B8G8R8_SRGB);
+    ENUM_NAME(VK_FORMAT_R8G8B8A8_UNORM);
+    ENUM_NAME(VK_FORMAT_R8G8B8A8_SNORM);
+    ENUM_NAME(VK_FORMAT_R8G8B8A8_USCALED);
+    ENUM_NAME(VK_FORMAT_R8G8B8A8_SSCALED);
+    ENUM_NAME(VK_FORMAT_R8G8B8A8_UINT);
+    ENUM_NAME(VK_FORMAT_R8G8B8A8_SINT);
+    ENUM_NAME(VK_FORMAT_R8G8B8A8_SRGB);
+    ENUM_NAME(VK_FORMAT_B8G8R8A8_UNORM);
+    ENUM_NAME(VK_FORMAT_B8G8R8A8_SNORM);
+    ENUM_NAME(VK_FORMAT_B8G8R8A8_USCALED);
+    ENUM_NAME(VK_FORMAT_B8G8R8A8_SSCALED);
+    ENUM_NAME(VK_FORMAT_B8G8R8A8_UINT);
+    ENUM_NAME(VK_FORMAT_B8G8R8A8_SINT);
+    ENUM_NAME(VK_FORMAT_B8G8R8A8_SRGB);
+    ENUM_NAME(VK_FORMAT_A8B8G8R8_UNORM_PACK32);
+    ENUM_NAME(VK_FORMAT_A8B8G8R8_SNORM_PACK32);
+    ENUM_NAME(VK_FORMAT_A8B8G8R8_USCALED_PACK32);
+    ENUM_NAME(VK_FORMAT_A8B8G8R8_SSCALED_PACK32);
+    ENUM_NAME(VK_FORMAT_A8B8G8R8_UINT_PACK32);
+    ENUM_NAME(VK_FORMAT_A8B8G8R8_SINT_PACK32);
+    ENUM_NAME(VK_FORMAT_A8B8G8R8_SRGB_PACK32);
+    ENUM_NAME(VK_FORMAT_A2R10G10B10_UNORM_PACK32);
+    ENUM_NAME(VK_FORMAT_A2R10G10B10_SNORM_PACK32);
+    ENUM_NAME(VK_FORMAT_A2R10G10B10_USCALED_PACK32);
+    ENUM_NAME(VK_FORMAT_A2R10G10B10_SSCALED_PACK32);
+    ENUM_NAME(VK_FORMAT_A2R10G10B10_UINT_PACK32);
+    ENUM_NAME(VK_FORMAT_A2R10G10B10_SINT_PACK32);
+    ENUM_NAME(VK_FORMAT_A2B10G10R10_UNORM_PACK32);
+    ENUM_NAME(VK_FORMAT_A2B10G10R10_SNORM_PACK32);
+    ENUM_NAME(VK_FORMAT_A2B10G10R10_USCALED_PACK32);
+    ENUM_NAME(VK_FORMAT_A2B10G10R10_SSCALED_PACK32);
+    ENUM_NAME(VK_FORMAT_A2B10G10R10_UINT_PACK32);
+    ENUM_NAME(VK_FORMAT_A2B10G10R10_SINT_PACK32);
+    ENUM_NAME(VK_FORMAT_R16_UNORM);
+    ENUM_NAME(VK_FORMAT_R16_SNORM);
+    ENUM_NAME(VK_FORMAT_R16_USCALED);
+    ENUM_NAME(VK_FORMAT_R16_SSCALED);
+    ENUM_NAME(VK_FORMAT_R16_UINT);
+    ENUM_NAME(VK_FORMAT_R16_SINT);
+    ENUM_NAME(VK_FORMAT_R16_SFLOAT);
+    ENUM_NAME(VK_FORMAT_R16G16_UNORM);
+    ENUM_NAME(VK_FORMAT_R16G16_SNORM);
+    ENUM_NAME(VK_FORMAT_R16G16_USCALED);
+    ENUM_NAME(VK_FORMAT_R16G16_SSCALED);
+    ENUM_NAME(VK_FORMAT_R16G16_UINT);
+    ENUM_NAME(VK_FORMAT_R16G16_SINT);
+    ENUM_NAME(VK_FORMAT_R16G16_SFLOAT);
+    ENUM_NAME(VK_FORMAT_R16G16B16_UNORM);
+    ENUM_NAME(VK_FORMAT_R16G16B16_SNORM);
+    ENUM_NAME(VK_FORMAT_R16G16B16_USCALED);
+    ENUM_NAME(VK_FORMAT_R16G16B16_SSCALED);
+    ENUM_NAME(VK_FORMAT_R16G16B16_UINT);
+    ENUM_NAME(VK_FORMAT_R16G16B16_SINT);
+    ENUM_NAME(VK_FORMAT_R16G16B16_SFLOAT);
+    ENUM_NAME(VK_FORMAT_R16G16B16A16_UNORM);
+    ENUM_NAME(VK_FORMAT_R16G16B16A16_SNORM);
+    ENUM_NAME(VK_FORMAT_R16G16B16A16_USCALED);
+    ENUM_NAME(VK_FORMAT_R16G16B16A16_SSCALED);
+    ENUM_NAME(VK_FORMAT_R16G16B16A16_UINT);
+    ENUM_NAME(VK_FORMAT_R16G16B16A16_SINT);
+    ENUM_NAME(VK_FORMAT_R16G16B16A16_SFLOAT);
+    ENUM_NAME(VK_FORMAT_R32_UINT);
+    ENUM_NAME(VK_FORMAT_R32_SINT);
+    ENUM_NAME(VK_FORMAT_R32_SFLOAT);
+    ENUM_NAME(VK_FORMAT_R32G32_UINT);
+    ENUM_NAME(VK_FORMAT_R32G32_SINT);
+    ENUM_NAME(VK_FORMAT_R32G32_SFLOAT);
+    ENUM_NAME(VK_FORMAT_R32G32B32_UINT);
+    ENUM_NAME(VK_FORMAT_R32G32B32_SINT);
+    ENUM_NAME(VK_FORMAT_R32G32B32_SFLOAT);
+    ENUM_NAME(VK_FORMAT_R32G32B32A32_UINT);
+    ENUM_NAME(VK_FORMAT_R32G32B32A32_SINT);
+    ENUM_NAME(VK_FORMAT_R32G32B32A32_SFLOAT);
+    ENUM_NAME(VK_FORMAT_R64_UINT);
+    ENUM_NAME(VK_FORMAT_R64_SINT);
+    ENUM_NAME(VK_FORMAT_R64_SFLOAT);
+    ENUM_NAME(VK_FORMAT_R64G64_UINT);
+    ENUM_NAME(VK_FORMAT_R64G64_SINT);
+    ENUM_NAME(VK_FORMAT_R64G64_SFLOAT);
+    ENUM_NAME(VK_FORMAT_R64G64B64_UINT);
+    ENUM_NAME(VK_FORMAT_R64G64B64_SINT);
+    ENUM_NAME(VK_FORMAT_R64G64B64_SFLOAT);
+    ENUM_NAME(VK_FORMAT_R64G64B64A64_UINT);
+    ENUM_NAME(VK_FORMAT_R64G64B64A64_SINT);
+    ENUM_NAME(VK_FORMAT_R64G64B64A64_SFLOAT);
+    ENUM_NAME(VK_FORMAT_B10G11R11_UFLOAT_PACK32);
+    ENUM_NAME(VK_FORMAT_E5B9G9R9_UFLOAT_PACK32);
+    ENUM_NAME(VK_FORMAT_D16_UNORM);
+    ENUM_NAME(VK_FORMAT_X8_D24_UNORM_PACK32);
+    ENUM_NAME(VK_FORMAT_D32_SFLOAT);
+    ENUM_NAME(VK_FORMAT_S8_UINT);
+    ENUM_NAME(VK_FORMAT_D16_UNORM_S8_UINT);
+    ENUM_NAME(VK_FORMAT_D24_UNORM_S8_UINT);
+    ENUM_NAME(VK_FORMAT_D32_SFLOAT_S8_UINT);
+    ENUM_NAME(VK_FORMAT_BC1_RGB_UNORM_BLOCK);
+    ENUM_NAME(VK_FORMAT_BC1_RGB_SRGB_BLOCK);
+    ENUM_NAME(VK_FORMAT_BC1_RGBA_UNORM_BLOCK);
+    ENUM_NAME(VK_FORMAT_BC1_RGBA_SRGB_BLOCK);
+    ENUM_NAME(VK_FORMAT_BC2_UNORM_BLOCK);
+    ENUM_NAME(VK_FORMAT_BC2_SRGB_BLOCK);
+    ENUM_NAME(VK_FORMAT_BC3_UNORM_BLOCK);
+    ENUM_NAME(VK_FORMAT_BC3_SRGB_BLOCK);
+    ENUM_NAME(VK_FORMAT_BC4_UNORM_BLOCK);
+    ENUM_NAME(VK_FORMAT_BC4_SNORM_BLOCK);
+    ENUM_NAME(VK_FORMAT_BC5_UNORM_BLOCK);
+    ENUM_NAME(VK_FORMAT_BC5_SNORM_BLOCK);
+    ENUM_NAME(VK_FORMAT_BC6H_UFLOAT_BLOCK);
+    ENUM_NAME(VK_FORMAT_BC6H_SFLOAT_BLOCK);
+    ENUM_NAME(VK_FORMAT_BC7_UNORM_BLOCK);
+    ENUM_NAME(VK_FORMAT_BC7_SRGB_BLOCK);
+    ENUM_NAME(VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK);
+    ENUM_NAME(VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK);
+    ENUM_NAME(VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK);
+    ENUM_NAME(VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK);
+    ENUM_NAME(VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK);
+    ENUM_NAME(VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK);
+    ENUM_NAME(VK_FORMAT_EAC_R11_UNORM_BLOCK);
+    ENUM_NAME(VK_FORMAT_EAC_R11_SNORM_BLOCK);
+    ENUM_NAME(VK_FORMAT_EAC_R11G11_UNORM_BLOCK);
+    ENUM_NAME(VK_FORMAT_EAC_R11G11_SNORM_BLOCK);
+    ENUM_NAME(VK_FORMAT_ASTC_4x4_UNORM_BLOCK);
+    ENUM_NAME(VK_FORMAT_ASTC_4x4_SRGB_BLOCK);
+    ENUM_NAME(VK_FORMAT_ASTC_5x4_UNORM_BLOCK);
+    ENUM_NAME(VK_FORMAT_ASTC_5x4_SRGB_BLOCK);
+    ENUM_NAME(VK_FORMAT_ASTC_5x5_UNORM_BLOCK);
+    ENUM_NAME(VK_FORMAT_ASTC_5x5_SRGB_BLOCK);
+    ENUM_NAME(VK_FORMAT_ASTC_6x5_UNORM_BLOCK);
+    ENUM_NAME(VK_FORMAT_ASTC_6x5_SRGB_BLOCK);
+    ENUM_NAME(VK_FORMAT_ASTC_6x6_UNORM_BLOCK);
+    ENUM_NAME(VK_FORMAT_ASTC_6x6_SRGB_BLOCK);
+    ENUM_NAME(VK_FORMAT_ASTC_8x5_UNORM_BLOCK);
+    ENUM_NAME(VK_FORMAT_ASTC_8x5_SRGB_BLOCK);
+    ENUM_NAME(VK_FORMAT_ASTC_8x6_UNORM_BLOCK);
+    ENUM_NAME(VK_FORMAT_ASTC_8x6_SRGB_BLOCK);
+    ENUM_NAME(VK_FORMAT_ASTC_8x8_UNORM_BLOCK);
+    ENUM_NAME(VK_FORMAT_ASTC_8x8_SRGB_BLOCK);
+    ENUM_NAME(VK_FORMAT_ASTC_10x5_UNORM_BLOCK);
+    ENUM_NAME(VK_FORMAT_ASTC_10x5_SRGB_BLOCK);
+    ENUM_NAME(VK_FORMAT_ASTC_10x6_UNORM_BLOCK);
+    ENUM_NAME(VK_FORMAT_ASTC_10x6_SRGB_BLOCK);
+    ENUM_NAME(VK_FORMAT_ASTC_10x8_UNORM_BLOCK);
+    ENUM_NAME(VK_FORMAT_ASTC_10x8_SRGB_BLOCK);
+    ENUM_NAME(VK_FORMAT_ASTC_10x10_UNORM_BLOCK);
+    ENUM_NAME(VK_FORMAT_ASTC_10x10_SRGB_BLOCK);
+    ENUM_NAME(VK_FORMAT_ASTC_12x10_UNORM_BLOCK);
+    ENUM_NAME(VK_FORMAT_ASTC_12x10_SRGB_BLOCK);
+    ENUM_NAME(VK_FORMAT_ASTC_12x12_UNORM_BLOCK);
+    ENUM_NAME(VK_FORMAT_ASTC_12x12_SRGB_BLOCK);
+    ENUM_DEFAULT(e);
+  }
+  return os;
+}
+
+
+std::ostream& operator << (std::ostream& os, VkImageType e) {
+  switch (e) {
+    ENUM_NAME(VK_IMAGE_TYPE_1D);
+    ENUM_NAME(VK_IMAGE_TYPE_2D);
+    ENUM_NAME(VK_IMAGE_TYPE_3D);
+    ENUM_DEFAULT(e);
+  }
+  return os;
+}
+
+
+std::ostream& operator << (std::ostream& os, VkImageTiling e) {
+  switch (e) {
+    ENUM_NAME(VK_IMAGE_TILING_OPTIMAL);
+    ENUM_NAME(VK_IMAGE_TILING_LINEAR);
+    ENUM_DEFAULT(e);
+  }
+  return os;
+}
+
+
+std::ostream& operator << (std::ostream& os, VkImageLayout e) {
+  switch (e) {
+    ENUM_NAME(VK_IMAGE_LAYOUT_UNDEFINED);
+    ENUM_NAME(VK_IMAGE_LAYOUT_GENERAL);
+    ENUM_NAME(VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL);
+    ENUM_NAME(VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL);
+    ENUM_NAME(VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL);
+    ENUM_NAME(VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL);
+    ENUM_NAME(VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL);
+    ENUM_NAME(VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL);
+    ENUM_NAME(VK_IMAGE_LAYOUT_PREINITIALIZED);
+    ENUM_NAME(VK_IMAGE_LAYOUT_PRESENT_SRC_KHR);
+    ENUM_NAME(VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR);
+    ENUM_DEFAULT(e);
+  }
+  return os;
+}
+
+
+std::ostream& operator << (std::ostream& os, VkImageViewType e) {
+  switch (e) {
+    ENUM_NAME(VK_IMAGE_VIEW_TYPE_1D);
+    ENUM_NAME(VK_IMAGE_VIEW_TYPE_2D);
+    ENUM_NAME(VK_IMAGE_VIEW_TYPE_3D);
+    ENUM_NAME(VK_IMAGE_VIEW_TYPE_CUBE);
+    ENUM_NAME(VK_IMAGE_VIEW_TYPE_1D_ARRAY);
+    ENUM_NAME(VK_IMAGE_VIEW_TYPE_2D_ARRAY);
+    ENUM_NAME(VK_IMAGE_VIEW_TYPE_CUBE_ARRAY);
+    ENUM_DEFAULT(e);
+  }
+  return os;
+}
+
+
+std::ostream& operator << (std::ostream& os, VkPresentModeKHR e) {
+  switch (e) {
+    ENUM_NAME(VK_PRESENT_MODE_IMMEDIATE_KHR);
+    ENUM_NAME(VK_PRESENT_MODE_MAILBOX_KHR);
+    ENUM_NAME(VK_PRESENT_MODE_FIFO_KHR);
+    ENUM_NAME(VK_PRESENT_MODE_FIFO_RELAXED_KHR);
+    ENUM_DEFAULT(e);
+  }
+  return os;
+}
+
+
+std::ostream& operator << (std::ostream& os, VkColorSpaceKHR e) {
+  switch (e) {
+    ENUM_NAME(VK_COLOR_SPACE_SRGB_NONLINEAR_KHR);
+    ENUM_DEFAULT(e);
+  }
+  return os;
+}
+
+
+std::ostream& operator << (std::ostream& os, VkOffset2D e) {
+  return os << "(" << e.x << "," << e.y << ")";
+}
+
+
+std::ostream& operator << (std::ostream& os, VkOffset3D e) {
+  return os << "(" << e.x << "," << e.y << "," << e.z << ")";
+}
+
+
+std::ostream& operator << (std::ostream& os, VkExtent2D e) {
+  return os << "(" << e.width << "," << e.height << ")";
+}
+
+
+std::ostream& operator << (std::ostream& os, VkExtent3D e) {
+  return os << "(" << e.width << "," << e.height << "," << e.depth << ")";
+}

src/dxvk/vulkan/dxvk_vulkan_names.h

@@ -0,0 +1,21 @@
+#pragma once
+
+#include <ostream>
+
+#include "../../util/util_enum.h"
+
+#include "dxvk_vulkan_loader_fn.h"
+
+std::ostream& operator << (std::ostream& os, VkPipelineCacheHeaderVersion e);
+std::ostream& operator << (std::ostream& os, VkResult e);
+std::ostream& operator << (std::ostream& os, VkFormat e);
+std::ostream& operator << (std::ostream& os, VkImageType e);
+std::ostream& operator << (std::ostream& os, VkImageTiling e);
+std::ostream& operator << (std::ostream& os, VkImageLayout e);
+std::ostream& operator << (std::ostream& os, VkImageViewType e);
+std::ostream& operator << (std::ostream& os, VkPresentModeKHR e);
+std::ostream& operator << (std::ostream& os, VkColorSpaceKHR e);
+std::ostream& operator << (std::ostream& os, VkOffset2D e);
+std::ostream& operator << (std::ostream& os, VkOffset3D e);
+std::ostream& operator << (std::ostream& os, VkExtent2D e);
+std::ostream& operator << (std::ostream& os, VkExtent3D e);

src/util/rc/util_rc_ptr.h

@@ -123,4 +123,9 @@ namespace dxvk {
     }
   };
   
+}
+
+template<typename T>
+std::ostream& operator << (std::ostream& os, const dxvk::Rc<T>& rc) {
+  return os << rc.ptr();
 }

src/util/util_enum.h

@@ -0,0 +1,7 @@
+#pragma once
+
+#define ENUM_NAME(name) \
+  case name: os << #name; break
+
+#define ENUM_DEFAULT(name) \
+  default: os << e

tests/dxvk/test_dxvk_triangle.cpp

@@ -45,7 +45,6 @@ public:
       m_dxvkCommandList, sync1, sync2);
     m_dxvkSwapchain->present(sync2);
     m_dxvkDevice->waitForIdle();
-    m_dxvkCommandList->reset();
   }
   
 private: