Added memoryless textures

Author: azhirnov

Graphics/GraphicsAccessories/src/GraphicsAccessories.cpp

@@ -848,6 +848,7 @@ const Char* GetBindFlagString(Uint32 BindFlag)
         BIND_FLAG_STR_CASE(BIND_DEPTH_STENCIL)
         BIND_FLAG_STR_CASE(BIND_UNORDERED_ACCESS)
         BIND_FLAG_STR_CASE(BIND_INDIRECT_DRAW_ARGS)
+        BIND_FLAG_STR_CASE(BIND_INPUT_ATTACHMENT)
         BIND_FLAG_STR_CASE(BIND_RAY_TRACING)
 #undef BIND_FLAG_STR_CASE
         default: UNEXPECTED("Unexpected bind flag ", BindFlag); return "";

Graphics/GraphicsEngine/include/DeviceContextBase.hpp

@@ -952,14 +952,15 @@ inline bool DeviceContextBase<ImplementationTraits>::SetRenderTargets(
         if (pRTView)
         {
             const auto& RTVDesc = pRTView->GetDesc();
+            const auto& TexDesc = pRTView->GetTexture()->GetDesc();
             DEV_CHECK_ERR(RTVDesc.ViewType == TEXTURE_VIEW_RENDER_TARGET,
                           "Texture view object named '", RTVDesc.Name ? RTVDesc.Name : "", "' has incorrect view type (", GetTexViewTypeLiteralName(RTVDesc.ViewType), "). Render target view is expected");
+            DEV_CHECK_ERR(m_pBoundFramebuffer || (TexDesc.MiscFlags & MISC_TEXTURE_FLAG_MEMORYLESS) == 0,
+                          "Memoryless render target '", TexDesc.Name, "' must be used within a framebuffer");
 
             // Use this RTV to set the render target size
             if (m_FramebufferWidth == 0)
             {
-                auto*       pTex     = pRTView->GetTexture();
-                const auto& TexDesc  = pTex->GetDesc();
                 m_FramebufferWidth   = std::max(TexDesc.Width >> RTVDesc.MostDetailedMip, 1U);
                 m_FramebufferHeight  = std::max(TexDesc.Height >> RTVDesc.MostDetailedMip, 1U);
                 m_FramebufferSlices  = RTVDesc.NumArraySlices;
@@ -968,7 +969,6 @@ inline bool DeviceContextBase<ImplementationTraits>::SetRenderTargets(
             else
             {
 #ifdef DILIGENT_DEVELOPMENT
-                const auto& TexDesc = pRTView->GetTexture()->GetDesc();
                 DEV_CHECK_ERR(m_FramebufferWidth == std::max(TexDesc.Width >> RTVDesc.MostDetailedMip, 1U),
                               "Render target width (", std::max(TexDesc.Width >> RTVDesc.MostDetailedMip, 1U), ") specified by RTV '", RTVDesc.Name, "' is inconsistent with the width of previously bound render targets (", m_FramebufferWidth, ")");
                 DEV_CHECK_ERR(m_FramebufferHeight == std::max(TexDesc.Height >> RTVDesc.MostDetailedMip, 1U),
@@ -994,14 +994,15 @@ inline bool DeviceContextBase<ImplementationTraits>::SetRenderTargets(
     if (pDepthStencil != nullptr)
     {
         const auto& DSVDesc = pDepthStencil->GetDesc();
+        const auto& TexDesc = pDepthStencil->GetTexture()->GetDesc();
         DEV_CHECK_ERR(DSVDesc.ViewType == TEXTURE_VIEW_DEPTH_STENCIL,
                       "Texture view object named '", DSVDesc.Name ? DSVDesc.Name : "", "' has incorrect view type (", GetTexViewTypeLiteralName(DSVDesc.ViewType), "). Depth stencil view is expected");
+        DEV_CHECK_ERR(m_pBoundFramebuffer || (TexDesc.MiscFlags & MISC_TEXTURE_FLAG_MEMORYLESS) == 0,
+                      "Memoryless depth buffer '", TexDesc.Name, "' must be used within a framebuffer");
 
         // Use depth stencil size to set render target size
         if (m_FramebufferWidth == 0)
         {
-            auto*       pTex     = pDepthStencil->GetTexture();
-            const auto& TexDesc  = pTex->GetDesc();
             m_FramebufferWidth   = std::max(TexDesc.Width >> DSVDesc.MostDetailedMip, 1U);
             m_FramebufferHeight  = std::max(TexDesc.Height >> DSVDesc.MostDetailedMip, 1U);
             m_FramebufferSlices  = DSVDesc.NumArraySlices;
@@ -1010,7 +1011,6 @@ inline bool DeviceContextBase<ImplementationTraits>::SetRenderTargets(
         else
         {
 #ifdef DILIGENT_DEVELOPMENT
-            const auto& TexDesc = pDepthStencil->GetTexture()->GetDesc();
             DEV_CHECK_ERR(m_FramebufferWidth == std::max(TexDesc.Width >> DSVDesc.MostDetailedMip, 1U),
                           "Depth-stencil target width (", std::max(TexDesc.Width >> DSVDesc.MostDetailedMip, 1U), ") specified by DSV '", DSVDesc.Name, "' is inconsistent with the width of previously bound render targets (", m_FramebufferWidth, ")");
             DEV_CHECK_ERR(m_FramebufferHeight == std::max(TexDesc.Height >> DSVDesc.MostDetailedMip, 1U),
@@ -2136,6 +2136,7 @@ inline void DeviceContextBase<ImplementationTraits>::DvpVerifyRenderTargets() co
         const auto& TilePipeline = m_pPipelineState->GetTilePipelineDesc();
         NumPipelineRenderTargets = TilePipeline.NumRenderTargets;
         PipelineRTVFormats       = TilePipeline.RTVFormats;
+        PipelineDSVFormat        = BoundDSVFormat; // to disable warning
     }
     else
     {

Graphics/GraphicsEngine/include/TextureBase.hpp

@@ -45,7 +45,7 @@ namespace Diligent
 struct CopyTextureAttribs;
 
 /// Validates texture description and throws an exception in case of an error.
-void ValidateTextureDesc(const TextureDesc& TexDesc) noexcept(false);
+void ValidateTextureDesc(const TextureDesc& TexDesc, const IRenderDevice* pDevice) noexcept(false);
 
 /// Validates and corrects texture view description; throws an exception in case of an error.
 void ValidatedAndCorrectTextureViewDesc(const TextureDesc& TexDesc, TextureViewDesc& ViewDesc) noexcept(false);
@@ -137,11 +137,11 @@ class TextureBase : public DeviceObjectBase<typename EngineImplTraits::TextureIn
                       ") correspond to one of ", pDevice->GetCommandQueueCount(), " available software command queues");
         this->m_Desc.ImmediateContextMask &= DeviceQueuesMask;
 
+        // Validate correctness of texture description
+        ValidateTextureDesc(this->m_Desc, this->m_pDevice);
+
         if ((this->m_Desc.BindFlags & BIND_INPUT_ATTACHMENT) != 0)
             this->m_Desc.BindFlags |= BIND_SHADER_RESOURCE;
-
-        // Validate correctness of texture description
-        ValidateTextureDesc(this->m_Desc);
     }
 
     IMPLEMENT_QUERY_INTERFACE_IN_PLACE(IID_Texture, TDeviceObjectBase)

Graphics/GraphicsEngine/interface/GraphicsTypes.h

@@ -981,7 +981,13 @@ DILIGENT_TYPED_ENUM(MISC_TEXTURE_FLAGS, Uint8)
     /// Allow automatic mipmap generation with ITextureView::GenerateMips()
 
     /// \note A texture must be created with BIND_RENDER_TARGET bind flag
-    MISC_TEXTURE_FLAG_GENERATE_MIPS = 0x01
+    MISC_TEXTURE_FLAG_GENERATE_MIPS = 0x01,
+
+    /// The texture will be used as a transient framebuffer attachment.
+
+    /// \note Memoryless textures must only be used within a render passes in a framebuffer,
+    ///       load operation must be CLEAR or DISCARD, store operation must be DISCARD.
+    MISC_TEXTURE_FLAG_MEMORYLESS    = 0x02,
 };
 DEFINE_FLAG_ENUM_OPERATORS(MISC_TEXTURE_FLAGS)
 
@@ -2213,6 +2219,10 @@ struct AdapterMemoryInfo
 
     /// Supported access types for the unified memory.
     CPU_ACCESS_FLAGS UnifiedMemoryCPUAccess DEFAULT_INITIALIZER(CPU_ACCESS_NONE);
+
+    /// Indicates if device supports color and depth attachments in on-chip memory.
+    /// If supported, it will be combination of the following flags: BIND_RENDER_TARGET, BIND_DEPTH_STENCIL, BIND_INPUT_ATTACHMENT.
+    BIND_FLAGS MemorylessTextureBindFlags DEFAULT_INITIALIZER(BIND_NONE);
 };
 typedef struct AdapterMemoryInfo AdapterMemoryInfo;
 

Graphics/GraphicsEngine/src/FramebufferBase.cpp

@@ -99,6 +99,22 @@ void ValidateFramebufferDesc(const FramebufferDesc& Desc) noexcept(false)
                                             " does not match the sample count (", Uint32{AttDesc.SampleCount},
                                             ") defined by the render pass for the same attachment.");
         }
+
+        if ((TexDesc.MiscFlags & MISC_TEXTURE_FLAG_MEMORYLESS) != 0)
+        {
+            const bool HasStencilComponent = GetTextureFormatAttribs(AttDesc.Format).ComponentType == COMPONENT_TYPE_DEPTH_STENCIL;
+
+            if (AttDesc.LoadOp == ATTACHMENT_LOAD_OP_LOAD ||
+                (HasStencilComponent && AttDesc.StencilLoadOp == ATTACHMENT_LOAD_OP_LOAD))
+            {
+                LOG_FRAMEBUFFER_ERROR_AND_THROW("memoryless attachment ", i, " is not compatible with ATTACHMENT_LOAD_OP_LOAD");
+            }
+            if (AttDesc.StoreOp == ATTACHMENT_STORE_OP_STORE ||
+                (HasStencilComponent && AttDesc.StencilStoreOp == ATTACHMENT_STORE_OP_STORE))
+            {
+                LOG_FRAMEBUFFER_ERROR_AND_THROW("memoryless attachment ", i, " is not compatible with ATTACHMENT_STORE_OP_STORE");
+            }
+        }
     }
 
     for (Uint32 i = 0; i < RPDesc.SubpassCount; ++i)

Graphics/GraphicsEngine/src/TextureBase.cpp

@@ -35,11 +35,12 @@
 namespace Diligent
 {
 
-void ValidateTextureDesc(const TextureDesc& Desc) noexcept(false)
+void ValidateTextureDesc(const TextureDesc& Desc, const IRenderDevice* pDevice) noexcept(false)
 {
 #define LOG_TEXTURE_ERROR_AND_THROW(...) LOG_ERROR_AND_THROW("Texture '", (Desc.Name ? Desc.Name : ""), "': ", ##__VA_ARGS__)
 
     const auto& FmtAttribs = GetTextureFormatAttribs(Desc.Format);
+    const auto& MemInfo    = pDevice->GetAdapterInfo().Memory;
 
     if (Desc.Type == RESOURCE_DIM_UNDEFINED)
     {
@@ -130,6 +131,24 @@ void ValidateTextureDesc(const TextureDesc& Desc) noexcept(false)
                                      "Use UNORM format instead.");
     }
 
+    if (Desc.MiscFlags & MISC_TEXTURE_FLAG_MEMORYLESS)
+    {
+        if (MemInfo.MemorylessTextureBindFlags == BIND_NONE)
+            LOG_TEXTURE_ERROR_AND_THROW("Memoryless textures are not supported by device");
+
+        if ((Desc.BindFlags & MemInfo.MemorylessTextureBindFlags) != Desc.BindFlags)
+            LOG_TEXTURE_ERROR_AND_THROW("BindFlags ", GetBindFlagsString(Desc.BindFlags & ~MemInfo.MemorylessTextureBindFlags), " are not supported for memoryless textures.");
+
+        if (Desc.Usage != USAGE_DEFAULT)
+            LOG_TEXTURE_ERROR_AND_THROW("Memoryless attachment requires USAGE_DEFAULT.");
+
+        if (Desc.CPUAccessFlags != 0)
+            LOG_TEXTURE_ERROR_AND_THROW("Memoryless attachment requires CPUAccessFlags to be NONE.");
+
+        if (Desc.MiscFlags & MISC_TEXTURE_FLAG_GENERATE_MIPS)
+            LOG_TEXTURE_ERROR_AND_THROW("Memoryless attachment is not compatible with mipmap generation.");
+    }
+
     if (Desc.Usage == USAGE_STAGING)
     {
         if (Desc.BindFlags != 0)

Graphics/GraphicsEngineVulkan/src/EngineFactoryVk.cpp

@@ -287,7 +287,11 @@ GraphicsAdapterInfo GetPhysicalDeviceGraphicsAdapterInfo(const VulkanUtilities::
             const auto&    MemTypeInfo        = MemoryProps.memoryTypes[type];
             constexpr auto UnifiedMemoryFlags = VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT | VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT;
 
-            if ((MemTypeInfo.propertyFlags & UnifiedMemoryFlags) == UnifiedMemoryFlags)
+            if (MemTypeInfo.propertyFlags & VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT)
+            {
+                Mem.MemorylessTextureBindFlags = BIND_RENDER_TARGET | BIND_DEPTH_STENCIL | BIND_INPUT_ATTACHMENT;
+            }
+            else if ((MemTypeInfo.propertyFlags & UnifiedMemoryFlags) == UnifiedMemoryFlags)
             {
                 UnifiedHeap[MemTypeInfo.heapIndex] = true;
                 if (MemTypeInfo.propertyFlags & VK_MEMORY_PROPERTY_HOST_COHERENT_BIT)
@@ -303,6 +307,13 @@ GraphicsAdapterInfo GetPhysicalDeviceGraphicsAdapterInfo(const VulkanUtilities::
             {
                 HostVisibleHeap[MemTypeInfo.heapIndex] = true;
             }
+
+            // In Metal, input attachment with memoryless texture must be used as an imageblock,
+            // which is not supported in SPIRV to MSL translator.
+#if PLATFORM_MACOS || PLATFORM_IOS
+            if (Mem.MemorylessTextureBindFlags != 0)
+                Mem.MemorylessTextureBindFlags = BIND_RENDER_TARGET | BIND_DEPTH_STENCIL;
+#endif
         }
 
         for (uint32_t heap = 0; heap < MemoryProps.memoryHeapCount; ++heap)

Graphics/GraphicsEngineVulkan/src/TextureVkImpl.cpp

@@ -56,6 +56,10 @@ TextureVkImpl::TextureVkImpl(IReferenceCounters*        pRefCounters,
     if (m_Desc.Usage == USAGE_IMMUTABLE && (pInitData == nullptr || pInitData->pSubResources == nullptr))
         LOG_ERROR_AND_THROW("Immutable textures must be initialized with data at creation time: pInitData can't be null");
 
+    const auto IsMemoryless = (m_Desc.MiscFlags & MISC_TEXTURE_FLAG_MEMORYLESS) != 0;
+    if (IsMemoryless && pInitData != nullptr && pInitData->pSubResources != nullptr)
+        LOG_ERROR_AND_THROW("Memoryless textures can't be initialized");
+
     const auto& FmtAttribs    = GetTextureFormatAttribs(m_Desc.Format);
     const auto& LogicalDevice = pRenderDeviceVk->GetLogicalDevice();
 
@@ -156,6 +160,7 @@ TextureVkImpl::TextureVkImpl(IReferenceCounters*        pRefCounters,
 
         if (m_Desc.MiscFlags & MISC_TEXTURE_FLAG_GENERATE_MIPS)
         {
+            VERIFY_EXPR(!IsMemoryless);
             if (CheckCSBasedMipGenerationSupport(ImageCI.format) && ImageView2DSupported)
             {
                 ImageCI.usage |= VK_IMAGE_USAGE_STORAGE_BIT;
@@ -199,11 +204,17 @@ TextureVkImpl::TextureVkImpl(IReferenceCounters*        pRefCounters,
         // and the transition away from this layout is not guaranteed to preserve that data.
         ImageCI.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
 
+        if (IsMemoryless)
+        {
+            ImageCI.usage &= (VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT | VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT);
+            ImageCI.usage |= VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT;
+        }
+
         m_VulkanImage = LogicalDevice.CreateImage(ImageCI, m_Desc.Name);
 
         VkMemoryRequirements MemReqs = LogicalDevice.GetImageMemoryRequirements(m_VulkanImage);
 
-        constexpr auto ImageMemoryFlags = VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT;
+        const auto ImageMemoryFlags = IsMemoryless ? VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT : VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT;
         VERIFY(IsPowerOfTwo(MemReqs.alignment), "Alignment is not power of 2!");
         m_MemoryAllocation = pRenderDeviceVk->AllocateMemory(MemReqs, ImageMemoryFlags);
         auto AlignedOffset = AlignUp(m_MemoryAllocation.UnalignedOffset, MemReqs.alignment);

Graphics/GraphicsEngineVulkan/src/VulkanTypeConversions.cpp

@@ -1968,6 +1968,14 @@ DeviceFeatures VkFeaturesToDeviceFeatures(uint32_t
     INIT_FEATURE(TileShaders, false); // Not currently supported
 #undef INIT_FEATURE
 
+    // Not supported in Vulkan on top of Metal.
+#if PLATFORM_MACOS || PLATFORM_IOS
+    Features.BinaryOcclusionQueries = DEVICE_FEATURE_STATE_DISABLED;
+    Features.TimestampQueries       = DEVICE_FEATURE_STATE_DISABLED;
+    Features.DurationQueries        = DEVICE_FEATURE_STATE_DISABLED;
+    Features.OcclusionQueries       = DEVICE_FEATURE_STATE_DISABLED;
+#endif
+
 #if defined(_MSC_VER) && defined(_WIN64)
     static_assert(sizeof(DeviceFeatures) == 37, "Did you add a new feature to DeviceFeatures? Please handle its satus here (if necessary).");
 #endif

Tests/DiligentCoreAPITest/src/RenderPassTest.cpp

@@ -180,7 +180,8 @@ class RenderPassTest : public ::testing::Test
         pContext->EndRenderPass();
     }
 
-    static void TestInputAttachment(bool UseSignature);
+    static void TestMSResolve(bool UseMemoryless);
+    static void TestInputAttachment(bool UseSignature, bool UseMemoryless);
 
     static void Present()
     {
@@ -551,7 +552,7 @@ TEST_F(RenderPassTest, Draw)
     Present();
 }
 
-TEST_F(RenderPassTest, MSResolve)
+void RenderPassTest::TestMSResolve(bool UseMemoryless)
 {
     auto* pEnv       = TestingEnvironment::GetInstance();
     auto* pDevice    = pEnv->GetDevice();
@@ -638,6 +639,7 @@ TEST_F(RenderPassTest, MSResolve)
         TexDesc.MipLevels   = 1;
         TexDesc.SampleCount = Attachments[0].SampleCount;
         TexDesc.Usage       = USAGE_DEFAULT;
+        TexDesc.MiscFlags   = UseMemoryless ? MISC_TEXTURE_FLAG_MEMORYLESS : MISC_TEXTURE_FLAG_NONE;
 
         pDevice->CreateTexture(TexDesc, nullptr, &pMSTex);
         ASSERT_NE(pMSTex, nullptr);
@@ -694,7 +696,24 @@ TEST_F(RenderPassTest, MSResolve)
     Present();
 }
 
-void RenderPassTest::TestInputAttachment(bool UseSignature)
+TEST_F(RenderPassTest, MSResolve)
+{
+    TestMSResolve(false);
+}
+
+TEST_F(RenderPassTest, MemorylessMSResolve)
+{
+    const auto  RequiredBindFlags = BIND_RENDER_TARGET;
+    const auto& MemoryInfo        = TestingEnvironment::GetInstance()->GetDevice()->GetAdapterInfo().Memory;
+
+    if ((MemoryInfo.MemorylessTextureBindFlags & RequiredBindFlags) != RequiredBindFlags)
+    {
+        GTEST_SKIP() << "Memoryless attachment is not supported by device";
+    }
+    TestMSResolve(true);
+}
+
+void RenderPassTest::TestInputAttachment(bool UseSignature, bool UseMemoryless)
 {
     auto* pEnv       = TestingEnvironment::GetInstance();
     auto* pDevice    = pEnv->GetDevice();
@@ -781,6 +800,7 @@ void RenderPassTest::TestInputAttachment(bool UseSignature)
         TexDesc.BindFlags = BIND_RENDER_TARGET | BIND_INPUT_ATTACHMENT;
         TexDesc.MipLevels = 1;
         TexDesc.Usage     = USAGE_DEFAULT;
+        TexDesc.MiscFlags = UseMemoryless ? MISC_TEXTURE_FLAG_MEMORYLESS : MISC_TEXTURE_FLAG_NONE;
 
         pDevice->CreateTexture(TexDesc, nullptr, &pTex);
         ASSERT_NE(pTex, nullptr);
@@ -979,12 +999,24 @@ void RenderPassTest::TestInputAttachment(bool UseSignature)
 
 TEST_F(RenderPassTest, InputAttachment)
 {
-    TestInputAttachment(false);
+    TestInputAttachment(false, false);
 }
 
 TEST_F(RenderPassTest, InputAttachmentWithSignature)
 {
-    TestInputAttachment(true);
+    TestInputAttachment(true, false);
+}
+
+TEST_F(RenderPassTest, MemorylessInputAttachment)
+{
+    const auto  RequiredBindFlags = BIND_RENDER_TARGET | BIND_INPUT_ATTACHMENT;
+    const auto& MemoryInfo        = TestingEnvironment::GetInstance()->GetDevice()->GetAdapterInfo().Memory;
+
+    if ((MemoryInfo.MemorylessTextureBindFlags & RequiredBindFlags) != RequiredBindFlags)
+    {
+        GTEST_SKIP() << "Memoryless attachment is not supported by device";
+    }
+    TestInputAttachment(false, true);
 }