Added subsampled render targets for VRS (API250011)

Author: azhirnov

Graphics/GraphicsAccessories/src/GraphicsAccessories.cpp

@@ -211,10 +211,8 @@ class TexFormatToViewFormatConverter
 #undef INIT_TVIEW_FORMAT_INFO
         // clang-format on
 
-        m_ViewFormats[TEX_FORMAT_R8_UINT][TEXTURE_VIEW_SHADING_RATE - 1]      = TEX_FORMAT_R8_UINT;
-        m_ViewFormats[TEX_FORMAT_R8_TYPELESS][TEXTURE_VIEW_SHADING_RATE - 1]  = TEX_FORMAT_R8_UINT;
-        m_ViewFormats[TEX_FORMAT_RG8_UNORM][TEXTURE_VIEW_SHADING_RATE - 1]    = TEX_FORMAT_RG8_UNORM;
-        m_ViewFormats[TEX_FORMAT_RG8_TYPELESS][TEXTURE_VIEW_SHADING_RATE - 1] = TEX_FORMAT_RG8_UNORM;
+        m_ViewFormats[TEX_FORMAT_R8_UINT][TEXTURE_VIEW_SHADING_RATE - 1]   = TEX_FORMAT_R8_UINT;
+        m_ViewFormats[TEX_FORMAT_RG8_UNORM][TEXTURE_VIEW_SHADING_RATE - 1] = TEX_FORMAT_RG8_UNORM;
     }
 
     TEXTURE_FORMAT GetViewFormat(TEXTURE_FORMAT Format, TEXTURE_VIEW_TYPE ViewType, Uint32 BindFlags)

Graphics/GraphicsEngine/CMakeLists.txt

@@ -92,6 +92,7 @@ set(SOURCE
     src/RenderDeviceBase.cpp
     src/ResourceMappingBase.cpp
     src/ShaderBindingTableBase.cpp
+    src/SamplerBase.cpp
     src/RenderPassBase.cpp
     src/TextureBase.cpp
     src/TopLevelASBase.cpp

Graphics/GraphicsEngine/include/DeviceContextBase.hpp

@@ -1104,6 +1104,34 @@ inline bool DeviceContextBase<ImplementationTraits>::SetRenderTargets(const SetR
         bBindRenderTargets     = true;
     }
 
+#ifdef DILIGENT_DEVELOPMENT
+    const auto& SRProps = m_pDevice->GetAdapterInfo().ShadingRate;
+    if (m_pBoundShadingRateMap &&
+        (SRProps.CapFlags & SHADING_RATE_CAP_FLAG_NON_SUBSAMPLED_RENDER_TARGET) == 0 &&
+        !m_pDevice->GetDeviceInfo().IsMetalDevice())
+    {
+        VERIFY((SRProps.CapFlags & SHADING_RATE_CAP_FLAG_SUBSAMPLED_RENDER_TARGET) != 0,
+               "One of NON_SUBSAMPLED_RENDER_TARGET or SUBSAMPLED_RENDER_TARGET caps must be presented if texture-based VRS is supported");
+
+        for (Uint32 i = 0; i < m_NumBoundRenderTargets; ++i)
+        {
+            if (auto& pRTV = m_pBoundRenderTargets[i])
+            {
+                DEV_CHECK_ERR((pRTV->GetTexture()->GetDesc().MiscFlags & MISC_TEXTURE_FLAG_SUBSAMPLED) != 0,
+                              "Render target used with shading rate map must be created with MISC_TEXTURE_FLAG_SUBSAMPLED flag when "
+                              "SHADING_RATE_CAP_FLAG_NON_SUBSAMPLED_RENDER_TARGET capability is not present.");
+            }
+        }
+
+        if (m_pBoundDepthStencil)
+        {
+            DEV_CHECK_ERR((m_pBoundDepthStencil->GetTexture()->GetDesc().MiscFlags & MISC_TEXTURE_FLAG_SUBSAMPLED) != 0,
+                          "Depth-stencil target used with shading rate map must be created with MISC_TEXTURE_FLAG_SUBSAMPLED flag when "
+                          "SHADING_RATE_CAP_FLAG_NON_SUBSAMPLED_RENDER_TARGET capability is not present.");
+        }
+    }
+#endif
+
     return bBindRenderTargets;
 }
 

Graphics/GraphicsEngine/include/FramebufferBase.hpp

@@ -39,7 +39,7 @@
 namespace Diligent
 {
 
-void ValidateFramebufferDesc(const FramebufferDesc& Desc, RENDER_DEVICE_TYPE DevType) noexcept(false);
+void ValidateFramebufferDesc(const FramebufferDesc& Desc, IRenderDevice* pDevice) noexcept(false);
 
 /// Template class implementing base functionality of the framebuffer object.
 
@@ -68,8 +68,7 @@ class FramebufferBase : public DeviceObjectBase<typename EngineImplTraits::Frame
         TDeviceObjectBase{pRefCounters, pDevice, Desc, bIsDeviceInternal},
         m_pRenderPass{Desc.pRenderPass}
     {
-        const auto& DeviceInfo = pDevice->GetDeviceInfo();
-        ValidateFramebufferDesc(this->m_Desc, DeviceInfo.Type);
+        ValidateFramebufferDesc(this->m_Desc, pDevice);
 
         if (this->m_Desc.Width == 0 || this->m_Desc.Height == 0 || this->m_Desc.NumArraySlices == 0)
         {

Graphics/GraphicsEngine/include/RenderDeviceBase.hpp

@@ -62,6 +62,7 @@ struct hash<Diligent::SamplerDesc>
             static_cast<int>(SamDesc.AddressU),
             static_cast<int>(SamDesc.AddressV),
             static_cast<int>(SamDesc.AddressW),
+            static_cast<int>(SamDesc.Flags),
             SamDesc.MipLODBias,
             SamDesc.MaxAnisotropy,
             static_cast<int>(SamDesc.ComparisonFunc),

Graphics/GraphicsEngine/include/SamplerBase.hpp

@@ -37,6 +37,9 @@
 namespace Diligent
 {
 
+/// Validates sampler description and throws an exception in case of an error.
+void ValidateSamplerDesc(const SamplerDesc& Desc, const IRenderDevice* pDevice) noexcept(false);
+
 /// Template class implementing base functionality of the sampler object.
 
 /// \tparam EngineImplTraits - Engine implementation type traits.
@@ -59,7 +62,9 @@ class SamplerBase : public DeviceObjectBase<typename EngineImplTraits::SamplerIn
     ///							   must not keep a strong reference to the device.
     SamplerBase(IReferenceCounters* pRefCounters, RenderDeviceImplType* pDevice, const SamplerDesc& SamDesc, bool bIsDeviceInternal = false) :
         TDeviceObjectBase{pRefCounters, pDevice, SamDesc, bIsDeviceInternal}
-    {}
+    {
+        ValidateSamplerDesc(this->m_Desc, pDevice);
+    }
 
     ~SamplerBase()
     {

Graphics/GraphicsEngine/include/ShaderResourceVariableBase.hpp

@@ -499,6 +499,10 @@ bool VerifySamplerBinding(const PipelineResourceDesc& ResDesc,
     {
         RESOURCE_VALIDATION_FAILURE("Buffer range can't be specified for samplers.");
     }
+    if (pSamplerImpl != nullptr && (pSamplerImpl->GetDesc().Flags & SAMPLER_FLAG_SUBSAMPLED) != 0)
+    {
+        RESOURCE_VALIDATION_FAILURE("Subsampled sampler must be added as an immutable sampler to the PSO or resource signature");
+    }
     return VerifyResourceBinding("sampler", ResDesc, BindInfo, pSamplerImpl, pCachedSampler, SignatureName);
 }
 

Graphics/GraphicsEngine/interface/APIInfo.h

@@ -30,7 +30,7 @@
 /// \file
 /// Diligent API information
 
-#define DILIGENT_API_VERSION 250010
+#define DILIGENT_API_VERSION 250011
 
 #include "../../../Primitives/interface/BasicTypes.h"
 

Graphics/GraphicsEngine/interface/GraphicsTypes.h

@@ -2450,57 +2450,87 @@ typedef struct ShadingRateMode ShadingRateMode;
 DILIGENT_TYPED_ENUM(SHADING_RATE_CAP_FLAGS, Uint16)
 {
     /// No shading rate capabilities.
-    SHADING_RATE_CAP_FLAG_NONE                = 0,
+    SHADING_RATE_CAP_FLAG_NONE                                  = 0,
 
     /// Shading rate can be specified for the whole draw call using IDeviceContext::SetShadingRate().
-    SHADING_RATE_CAP_FLAG_PER_DRAW            = 1u << 0,
+    SHADING_RATE_CAP_FLAG_PER_DRAW                              = 1u << 0,
 
     /// Shading rate can be specified in the vertex shader for each primitive and combined with the base rate.
     /// Use IDeviceContext::SetShadingRate() to set base rate and per-primitive combiner.
-    SHADING_RATE_CAP_FLAG_PER_PRIMITIVE       = 1u << 1,
+    SHADING_RATE_CAP_FLAG_PER_PRIMITIVE                         = 1u << 1,
 
     /// Shading rate is specified by a texture, each texel defines a shading rate for the tile.
     /// Supported tile size is specified in ShadingRateProperties::MinTileSize/MaxTileSize.
     /// Use IDeviceContext::SetShadingRate() to set the base rate and texture combiner.
     /// Use IDeviceContext::SetRenderTargetsExt() to set the shading rate texture.
-    SHADING_RATE_CAP_FLAG_TEXTURE_BASED       = 1u << 2,
+    SHADING_RATE_CAP_FLAG_TEXTURE_BASED                         = 1u << 2,
 
     /// Allows to set zero bits in GraphicsPipelineDesc::SampleMask
     /// with the enabled variable rate shading.
-    SHADING_RATE_CAP_FLAG_SAMPLE_MASK         = 1u << 3,
+    SHADING_RATE_CAP_FLAG_SAMPLE_MASK                           = 1u << 3,
 
     /// Allows to get or set SampleMask in the shader with enabled variable rate shading.
     /// HLSL: SV_Coverage, GLSL: gl_SampleMaskIn, gl_SampleMask.
-    SHADING_RATE_CAP_FLAG_SHADER_SAMPLE_MASK  = 1u << 4,
+    SHADING_RATE_CAP_FLAG_SHADER_SAMPLE_MASK                    = 1u << 4,
 
     /// Allows to write depth and stencil from the pixel shader.
-    SHADING_RATE_CAP_FLAG_SHADER_DEPTH_STENCIL_WRITE = 1u << 5,
+    SHADING_RATE_CAP_FLAG_SHADER_DEPTH_STENCIL_WRITE            = 1u << 5,
 
     /// Allows to use per primitive shading rate when multiple viewports are used.
     SHADING_RATE_CAP_FLAG_PER_PRIMITIVE_WITH_MULTIPLE_VIEWPORTS = 1u << 6,
 
     /// Shading rate attachment for render pass must be the same for all subpasses.
     /// See SubpassDesc::pShadingRateAttachment.
-    SHADING_RATE_CAP_FLAG_SAME_TEXTURE_FOR_WHOLE_RENDERPASS = 1u << 7,
+    SHADING_RATE_CAP_FLAG_SAME_TEXTURE_FOR_WHOLE_RENDERPASS     = 1u << 7,
 
     /// Allows to use texture 2D array for shading rate.
-    SHADING_RATE_CAP_FLAG_TEXTURE_ARRAY            = 1u << 8,
+    SHADING_RATE_CAP_FLAG_TEXTURE_ARRAY                         = 1u << 8,
 
     /// Allows to read current shading rate in the pixel shader.
     /// HLSL: in SV_ShadingRate, GLSL: gl_ShadingRate.
-    SHADING_RATE_CAP_FLAG_SHADING_RATE_SHADER_INPUT = 1u << 9,
-
-    /// Indicates that VRS texture is accessed on the GPU side.
-    /// If the flag is not set, the texture content is accessed
-    /// on the CPU side when render pass begins.
-    SHADING_RATE_CAP_FLAG_TEXTURE_DEVICE_ACCESS     = 1u << 10,
+    SHADING_RATE_CAP_FLAG_SHADING_RATE_SHADER_INPUT             = 1u << 9,
 
     /// Indicates that driver may generate additional fragment shader invocations
     /// in order to make transitions between fragment areas with different shading rates more smooth.
-    SHADING_RATE_CAP_FLAG_ADDITIONAL_INVOCATIONS    = 1u << 11,
+    SHADING_RATE_CAP_FLAG_ADDITIONAL_INVOCATIONS                = 1u << 10,
+
+    /// Indicates that there are no additional requirements for render targets
+    /// that are used in texture-based VRS rendering.
+    SHADING_RATE_CAP_FLAG_NON_SUBSAMPLED_RENDER_TARGET          = 1u << 11,
+
+    /// Indicates that render targets that are used in texture-based VRS rendering
+    /// must be created with MISC_TEXTURE_FLAG_SUBSAMPLED flag.
+    /// Intermediate targets must be scaled to the final resolution in a separate pass.
+    /// Intermediate targets can only be sampled with an immutable sampler created with SAMPLER_FLAG_SUBSAMPLED flag.
+    /// If supported, rendering to the subsampled render targets may be more optimal.
+    /// 
+    /// \note  Both NON_SUBSAMPLED and SUBSAMPLED modes may be supported by a device.
+    SHADING_RATE_CAP_FLAG_SUBSAMPLED_RENDER_TARGET              = 1u << 12
 };
 DEFINE_FLAG_ENUM_OPERATORS(SHADING_RATE_CAP_FLAGS);
 
+/// Defines how the shading rate texture is accessed
+DILIGENT_TYPED_ENUM(SHADING_RATE_TEXTURE_ACCESS, Uint8)
+{
+    /// Shading rate texture access type is unknown
+    SHADING_RATE_TEXTURE_ACCESS_UNKNOWN = 0,
+
+    /// Shading rate texture is accessed by the GPU when command buffer is executed.
+    SHADING_RATE_TEXTURE_ACCESS_ON_GPU,
+
+    /// Shading rate texture is accessed by the CPU when command buffer is submitted
+    /// for execution. An application is not allowed to modify the texture until the command
+    /// buffer is executed by the GPU. Feneces or other synchronization methods must be used
+    /// to control the access to the texture.
+    SHADING_RATE_TEXTURE_ACCESS_ON_SUBMIT,
+
+    /// Shading rate texture is accessed by the CPU when SetRenderTargetsEx or BeginRenderPass
+    /// command is executed. An application is not allowed to modify the texture until the
+    /// command buffer is executed by GPU. Feneces or other synchronization methods must be used
+    /// to control the access to the texture.
+    SHADING_RATE_TEXTURE_ACCESS_ON_SET_RTV
+};
+
 /// Shading rate properties
 struct ShadingRateProperties
 {
@@ -2509,7 +2539,7 @@ struct ShadingRateProperties
     ShadingRateMode        ShadingRates [DILIGENT_MAX_SHADING_RATES]  DEFAULT_INITIALIZER({});
 
     /// The number of valid elements in ShadingRates array.
-    Uint32                 NumShadingRates DEFAULT_INITIALIZER(0);
+    Uint8                  NumShadingRates DEFAULT_INITIALIZER(0);
 
     /// Shading rate capability flags, see Diligent::SHADING_RATE_CAP_FLAGS.
     SHADING_RATE_CAP_FLAGS CapFlags       DEFAULT_INITIALIZER(SHADING_RATE_CAP_FLAG_NONE);
@@ -2520,13 +2550,22 @@ struct ShadingRateProperties
     /// Indicates which shading rate texture format is used by this device (see Diligent::SHADING_RATE_FORMAT).
     SHADING_RATE_FORMAT    Format         DEFAULT_INITIALIZER(SHADING_RATE_FORMAT_UNKNOWN);
 
+    /// Shading rate texture access type (see Diligent::SHADING_RATE_TEXTURE_ACCESS).
+    SHADING_RATE_TEXTURE_ACCESS ShadingRateTextureAccess DEFAULT_INITIALIZER(SHADING_RATE_TEXTURE_ACCESS_UNKNOWN);
+
+    /// Indicates which bind flags are allowed for shading rate texture.
+    BIND_FLAGS             BindFlags      DEFAULT_INITIALIZER(BIND_NONE);
+
     /// Minimal supported tile size.
     /// Shading rate texture size must be less than or equal to (framebuffer_size / MinTileSize).
     Uint32                 MinTileSize[2] DEFAULT_INITIALIZER({});
 
     /// Maximum supported tile size.
     /// Shading rate texture size must be greater than or equal to (framebuffer_size / MaxTileSize).
     Uint32                 MaxTileSize[2] DEFAULT_INITIALIZER({});
+
+    /// Maximum size of the texture array created with MISC_TEXTURE_FLAG_SUBSAMPLED flag.
+    Uint32                 MaxSabsampledArraySlices DEFAULT_INITIALIZER(0);
 };
 typedef struct ShadingRateProperties ShadingRateProperties;
 

Graphics/GraphicsEngine/interface/Sampler.h

@@ -42,6 +42,23 @@ static const INTERFACE_ID IID_Sampler =
 
 // clang-format off
 
+/// Sampler flags
+DILIGENT_TYPED_ENUM(SAMPLER_FLAGS, Uint8)
+{
+    SAMPLER_FLAG_NONE        = 0,
+
+    /// Specifies that the sampler will read from a subsampled texture created with MISC_TEXTURE_FLAG_SUBSAMPLED flag.
+    /// Requires SHADING_RATE_CAP_FLAG_SUBSAMPLED_RENDER_TARGET capability.
+    SAMPLER_FLAG_SUBSAMPLED  = 1u << 0,
+
+    /// Specifies that the GPU is allowed to use fast approximation when reconstructing full-resolution value from
+    /// the subsampled texture accessed by the sampler.
+    /// Requires SHADING_RATE_CAP_FLAG_SUBSAMPLED_RENDER_TARGET capability.
+    SAMPLER_FLAG_SUBSAMPLED_COARSE_RECONSTRUCTION = 1u << 1,
+};
+DEFINE_FLAG_ENUM_OPERATORS(SAMPLER_FLAGS)
+
+
 /// Sampler description
 
 /// This structure describes the sampler state which is used in a call to
@@ -83,6 +100,9 @@ struct SamplerDesc DILIGENT_DERIVE(DeviceObjectAttribs)
     /// Default value: Diligent::TEXTURE_ADDRESS_CLAMP.
     TEXTURE_ADDRESS_MODE AddressW   DEFAULT_INITIALIZER(TEXTURE_ADDRESS_CLAMP);
 
+    /// Sampler flags, see Diligent::SAMPLER_FLAGS for details.
+    SAMPLER_FLAGS        Flags      DEFAULT_INITIALIZER(SAMPLER_FLAG_NONE);
+
     /// Offset from the calculated mipmap level. For example, if a sampler calculates that a texture
     /// should be sampled at mipmap level 1.2 and MipLODBias is 2.3, then the texture will be sampled at
     /// mipmap level 3.5. Default value: 0.
@@ -123,13 +143,15 @@ struct SamplerDesc DILIGENT_DERIVE(DeviceObjectAttribs)
                           Uint32               _MaxAnisotropy  = SamplerDesc{}.MaxAnisotropy,
                           COMPARISON_FUNCTION  _ComparisonFunc = SamplerDesc{}.ComparisonFunc,
                           float                _MinLOD         = SamplerDesc{}.MinLOD,
-                          float                _MaxLOD         = SamplerDesc{}.MaxLOD) :
+                          float                _MaxLOD         = SamplerDesc{}.MaxLOD,
+                          SAMPLER_FLAGS        _Flags          = SamplerDesc{}.Flags) :
         MinFilter      {_MinFilter     },
         MagFilter      {_MagFilter     },
         MipFilter      {_MipFilter     },
         AddressU       {_AddressU      },
         AddressV       {_AddressV      },
         AddressW       {_AddressW      },
+        Flags          {_Flags         },
         MipLODBias     {_MipLODBias    },
         MaxAnisotropy  {_MaxAnisotropy },
         ComparisonFunc {_ComparisonFunc},
@@ -157,6 +179,7 @@ struct SamplerDesc DILIGENT_DERIVE(DeviceObjectAttribs)
                 AddressU        == RHS.AddressU       &&
                 AddressV        == RHS.AddressV       &&
                 AddressW        == RHS.AddressW       &&
+                Flags           == RHS.Flags          &&
                 MipLODBias      == RHS.MipLODBias     &&
                 MaxAnisotropy   == RHS.MaxAnisotropy  &&
                 ComparisonFunc  == RHS.ComparisonFunc &&