merge misc commits i had done locally #2

README.md

@@ -36,7 +36,6 @@ A huge thank-you to the following contributors for their invaluable help:
 - [Shader Compilation (dyasync)](#shader-compilation-dyasync)
 - [Frame Pacing (low-latency mode)](#frame-pacing-low-latency-mode)
 - [Debugging](#debugging)
-- [Debugging](#debugging)
 - [Troubleshooting](#troubleshooting)
 
 ## Proton-Sarek: discontinued

dxvk.conf

@@ -447,6 +447,44 @@
 # dxvk.numDyasyncThreads = 0
 
 
+# Frame Pacing
+#
+# Controls how DXVK-Sarek paces CPU frame submission relative to
+# GPU completion. Adapted from netborg-afps/dxvk-low-latency, with
+# the mechanism reworked around what Sarek's Vulkan 1.1/1.2 presenter
+# can actually observe (no per-submission GPU timing telemetry).
+#
+# Supported values:
+# - max-frame-latency: Default. Sarek's existing, unchanged behaviour.
+#     Frame i won't start until frame (i-1)-x has finished, where x is
+#     dxgi.maxFrameLatency / d3d9.maxFrameLatency.
+# - low-latency: Forces the effective frame latency down to the minimum
+#     needed for forward progress, and uses a best-effort prediction of
+#     when the previous frame will finish (rolling average of recent
+#     frame durations) to reduce CPU wake-up jitter. A wrong prediction
+#     costs microseconds, never a broken frame.
+# - min-latency: Same minimal frame latency without the predictive
+#     sleep. Lowest possible latency, usually at a noticeable fps cost.
+#
+# Note: because the presenter lacks per-submission GPU progress
+# telemetry, low-latency and min-latency currently share the same
+# underlying latency-reduction mechanism. There is no VRR-aware pacing
+# mode and no HUD latency display yet.
+
+# dxvk.framePace = "max-frame-latency"
+
+
+# Low latency offset
+#
+# Fine-tunes low-latency mode: positive values (in microseconds) delay
+# a frame's predicted start slightly, negative values start it earlier.
+# Only takes effect when dxvk.framePace = "low-latency".
+#
+# Supported values: -10000 to 10000
+
+# dxvk.lowLatencyOffset = 0
+
+
 # Toggles raw SSBO usage.
 #
 # Uses storage buffers to implement raw and structured buffer
@@ -1022,4 +1060,3 @@
 # - True/False
 
 # ddraw.legacyDeviceNames = False
-

src/d3d11/d3d11_buffer.cpp

@@ -5,7 +5,7 @@
 #include "../dxvk/dxvk_data.h"
 
 namespace dxvk {
-  
+
   D3D11Buffer::D3D11Buffer(
           D3D11Device*                pDevice,
     const D3D11_BUFFER_DESC*          pDesc)
@@ -20,19 +20,19 @@ namespace dxvk {
     info.stages = VK_PIPELINE_STAGE_TRANSFER_BIT;
     info.access = VK_ACCESS_TRANSFER_READ_BIT
                 | VK_ACCESS_TRANSFER_WRITE_BIT;
-    
+
     if (pDesc->BindFlags & D3D11_BIND_VERTEX_BUFFER) {
       info.usage  |= VK_BUFFER_USAGE_VERTEX_BUFFER_BIT;
       info.stages |= VK_PIPELINE_STAGE_VERTEX_INPUT_BIT;
       info.access |= VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT;
     }
-    
+
     if (pDesc->BindFlags & D3D11_BIND_INDEX_BUFFER) {
       info.usage  |= VK_BUFFER_USAGE_INDEX_BUFFER_BIT;
       info.stages |= VK_PIPELINE_STAGE_VERTEX_INPUT_BIT;
       info.access |= VK_ACCESS_INDEX_READ_BIT;
     }
-    
+
     if (pDesc->BindFlags & D3D11_BIND_CONSTANT_BUFFER) {
       info.usage  |= VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT;
       info.stages |= m_parent->GetEnabledShaderStages();
@@ -41,28 +41,28 @@ namespace dxvk {
       if (m_parent->GetOptions()->constantBufferRangeCheck)
         info.usage |= VK_BUFFER_USAGE_STORAGE_BUFFER_BIT;
     }
-    
+
     if (pDesc->BindFlags & D3D11_BIND_SHADER_RESOURCE) {
       info.usage  |= VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT
                   |  VK_BUFFER_USAGE_STORAGE_BUFFER_BIT;
       info.stages |= m_parent->GetEnabledShaderStages();
       info.access |= VK_ACCESS_SHADER_READ_BIT;
     }
-    
+
     if (pDesc->BindFlags & D3D11_BIND_STREAM_OUTPUT) {
       info.usage  |= VK_BUFFER_USAGE_TRANSFORM_FEEDBACK_BUFFER_BIT_EXT;
       info.stages |= VK_PIPELINE_STAGE_TRANSFORM_FEEDBACK_BIT_EXT;
       info.access |= VK_ACCESS_TRANSFORM_FEEDBACK_WRITE_BIT_EXT;
     }
-    
+
     if (pDesc->BindFlags & D3D11_BIND_UNORDERED_ACCESS) {
       info.usage  |= VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT
                   |  VK_BUFFER_USAGE_STORAGE_BUFFER_BIT;
       info.stages |= m_parent->GetEnabledShaderStages();
       info.access |= VK_ACCESS_SHADER_READ_BIT
                   |  VK_ACCESS_SHADER_WRITE_BIT;
     }
-    
+
     if (pDesc->MiscFlags & D3D11_RESOURCE_MISC_DRAWINDIRECT_ARGS) {
       info.usage  |= VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT;
       info.stages |= VK_PIPELINE_STAGE_DRAW_INDIRECT_BIT;
@@ -80,27 +80,27 @@ namespace dxvk {
     if (pDesc->BindFlags & D3D11_BIND_STREAM_OUTPUT)
       m_soCounter = CreateSoCounterBuffer();
   }
-  
-  
+
+
   D3D11Buffer::~D3D11Buffer() {
 
   }
-  
-  
+
+
   HRESULT STDMETHODCALLTYPE D3D11Buffer::QueryInterface(REFIID riid, void** ppvObject) {
     if (ppvObject == nullptr)
       return E_POINTER;
 
     *ppvObject = nullptr;
-    
+
     if (riid == __uuidof(IUnknown)
      || riid == __uuidof(ID3D11DeviceChild)
      || riid == __uuidof(ID3D11Resource)
      || riid == __uuidof(ID3D11Buffer)) {
       *ppvObject = ref(this);
       return S_OK;
     }
-    
+
     if (riid == __uuidof(ID3D10DeviceChild)
      || riid == __uuidof(ID3D10Resource)
      || riid == __uuidof(ID3D10Buffer)) {
@@ -115,36 +115,36 @@ namespace dxvk {
        *ppvObject = ref(&m_resource);
        return S_OK;
     }
-    
+
     Logger::warn("D3D11Buffer::QueryInterface: Unknown interface query");
     Logger::warn(str::format(riid));
     return E_NOINTERFACE;
   }
-  
-  
+
+
   UINT STDMETHODCALLTYPE D3D11Buffer::GetEvictionPriority() {
     return DXGI_RESOURCE_PRIORITY_NORMAL;
   }
-  
-  
+
+
   void STDMETHODCALLTYPE D3D11Buffer::SetEvictionPriority(UINT EvictionPriority) {
     static bool s_errorShown = false;
 
     if (!std::exchange(s_errorShown, true))
       Logger::warn("D3D11Buffer::SetEvictionPriority: Stub");
   }
-  
-  
+
+
   void STDMETHODCALLTYPE D3D11Buffer::GetType(D3D11_RESOURCE_DIMENSION* pResourceDimension) {
     *pResourceDimension = D3D11_RESOURCE_DIMENSION_BUFFER;
   }
-  
-  
+
+
   void STDMETHODCALLTYPE D3D11Buffer::GetDesc(D3D11_BUFFER_DESC* pDesc) {
     *pDesc = m_desc;
   }
-  
-  
+
+
   bool D3D11Buffer::CheckViewCompatibility(
           UINT                BindFlags,
           DXGI_FORMAT         Format) const {
@@ -173,7 +173,7 @@ namespace dxvk {
     // We don't support tiled resources
     if (pDesc->MiscFlags & (D3D11_RESOURCE_MISC_TILE_POOL | D3D11_RESOURCE_MISC_TILED))
       return E_INVALIDARG;
-    
+
     // Constant buffer size must be a multiple of 16
     if ((pDesc->BindFlags & D3D11_BIND_CONSTANT_BUFFER)
      && (pDesc->ByteWidth & 0xF))
@@ -185,7 +185,7 @@ namespace dxvk {
       || (pDesc->StructureByteStride == 0)
       || (pDesc->StructureByteStride & 0x3)))
       return E_INVALIDARG;
-    
+
     // Basic validation for raw buffers
     if ((pDesc->MiscFlags & D3D11_RESOURCE_MISC_BUFFER_ALLOW_RAW_VIEWS)
      && (!(pDesc->BindFlags & (D3D11_BIND_SHADER_RESOURCE | D3D11_BIND_UNORDERED_ACCESS))))
@@ -194,10 +194,10 @@ namespace dxvk {
     // Mip generation obviously doesn't work for buffers
     if (pDesc->MiscFlags & D3D11_RESOURCE_MISC_GENERATE_MIPS)
       return E_INVALIDARG;
-    
+
     if (!(pDesc->MiscFlags & D3D11_RESOURCE_MISC_BUFFER_STRUCTURED))
       pDesc->StructureByteStride = 0;
-    
+
     return S_OK;
   }
 
@@ -212,7 +212,10 @@ namespace dxvk {
 
   VkMemoryPropertyFlags D3D11Buffer::GetMemoryFlags() const {
     VkMemoryPropertyFlags memoryFlags = 0;
-
+
+    if (m_desc.MiscFlags & (D3D11_RESOURCE_MISC_TILE_POOL | D3D11_RESOURCE_MISC_TILED))
+      return VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT;
+
     switch (m_desc.Usage) {
       case D3D11_USAGE_IMMUTABLE:
         memoryFlags |= VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT;
@@ -231,26 +234,27 @@ namespace dxvk {
           memoryFlags &= ~VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT;
         }
         break;
-      
+
       case D3D11_USAGE_DYNAMIC:
         memoryFlags |= VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT
                     |  VK_MEMORY_PROPERTY_HOST_COHERENT_BIT;
 
         if (m_desc.BindFlags)
           memoryFlags |= VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT;
         break;
-      
+
       case D3D11_USAGE_STAGING:
         memoryFlags |= VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT
                     |  VK_MEMORY_PROPERTY_HOST_COHERENT_BIT
                     |  VK_MEMORY_PROPERTY_HOST_CACHED_BIT;
         break;
     }
-    
+
     bool useCached = (m_parent->GetOptions()->cachedDynamicResources == ~0u)
                   || (m_parent->GetOptions()->cachedDynamicResources & m_desc.BindFlags);
 
     if ((memoryFlags & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT) && useCached) {
+      memoryFlags &= ~VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT;
       memoryFlags |= VK_MEMORY_PROPERTY_HOST_COHERENT_BIT
                   |  VK_MEMORY_PROPERTY_HOST_CACHED_BIT;
     }
@@ -285,7 +289,7 @@ namespace dxvk {
       ? D3D11_COMMON_BUFFER_MAP_MODE_DIRECT
       : D3D11_COMMON_BUFFER_MAP_MODE_NONE;
   }
-  
+
 
   D3D11Buffer* GetCommonBuffer(ID3D11Resource* pResource) {
     D3D11_RESOURCE_DIMENSION dimension = D3D11_RESOURCE_DIMENSION_UNKNOWN;

src/d3d11/d3d11_device.cpp

@@ -130,6 +130,9 @@ namespace dxvk {
     if (FAILED(hr))
       return hr;
 
+    if (desc.MiscFlags & D3D11_RESOURCE_MISC_TILED)
+      return E_INVALIDARG;
+
     if (!ppTexture1D)
       return S_FALSE;
 
@@ -816,6 +819,8 @@ namespace dxvk {
     InitReturnPtr(ppGeometryShader);
     D3D11CommonShader module;
 
+    if (!m_dxvkDevice->features().extTransformFeedback.transformFeedback)
+      return DXGI_ERROR_INVALID_CALL;
 
     // Zero-init some counterss so that we can increment
     // them while walking over the stream output entries
@@ -1381,6 +1386,22 @@ namespace dxvk {
           ID3D11Resource*             pSrcResource,
           UINT                        SrcSubresource,
     const D3D11_BOX*                  pSrcBox) {
+    auto texture = GetCommonTexture(pSrcResource);
+
+    if (!texture)
+      return;
+
+    if (texture->Desc()->Usage != D3D11_USAGE_DEFAULT
+     || texture->GetMapMode() == D3D11_COMMON_TEXTURE_MAP_MODE_NONE
+     || texture->CountSubresources() <= SrcSubresource)
+      return;
+
+    uint32_t map = texture->GetMapType(SrcSubresource);
+
+    if (map != uint32_t(D3D11_MAP_READ)
+     && map != uint32_t(D3D11_MAP_READ_WRITE))
+      return;
+
     CopySubresourceData(
       pDstData, DstRowPitch, DstDepthPitch,
       pSrcResource, SrcSubresource, pSrcBox);
@@ -1394,6 +1415,23 @@ namespace dxvk {
     const void*                       pSrcData,
           UINT                        SrcRowPitch,
           UINT                        SrcDepthPitch) {
+    auto texture = GetCommonTexture(pDstResource);
+
+    if (!texture)
+      return;
+
+    if (texture->Desc()->Usage != D3D11_USAGE_DEFAULT
+     || texture->GetMapMode() == D3D11_COMMON_TEXTURE_MAP_MODE_NONE
+     || texture->CountSubresources() <= DstSubresource)
+      return;
+
+    uint32_t map = texture->GetMapType(DstSubresource);
+
+    if (map != uint32_t(D3D11_MAP_WRITE)
+     && map != uint32_t(D3D11_MAP_WRITE_NO_OVERWRITE)
+     && map != uint32_t(D3D11_MAP_READ_WRITE))
+      return;
+
     CopySubresourceData(
       pSrcData, SrcRowPitch, SrcRowPitch,
       pDstResource, DstSubresource, pDstBox);

src/d3d11/d3d11_fence.cpp

@@ -2,7 +2,7 @@
 #include "d3d11_device.h"
 
 namespace dxvk {
-  
+
   D3D11Fence::D3D11Fence(
           D3D11Device*        pDevice,
           UINT64              InitialValue,
@@ -39,7 +39,7 @@ namespace dxvk {
       return E_POINTER;
 
     *ppvObject = nullptr;
-    
+
     if (riid == __uuidof(IUnknown)
      || riid == __uuidof(ID3D11DeviceChild)
      || riid == __uuidof(ID3D11Fence)) {
@@ -97,5 +97,5 @@ namespace dxvk {
 
     return m_fence->getValue();
   }
-  
+
 }