Defined SubpassDesc struct

3 files changed, 251 insertions, 2 deletions

diff --git a/Graphics/GraphicsEngine/include/RenderPassBase.hpp b/Graphics/GraphicsEngine/include/RenderPassBase.hpp
index 03fecd78..a8d73dc2 100644
--- a/Graphics/GraphicsEngine/include/RenderPassBase.hpp
+++ b/Graphics/GraphicsEngine/include/RenderPassBase.hpp
@@ -76,6 +76,20 @@ public:
             }
         }
 
+        Uint32 TotalAttachmentReferencesCount = 0;
+        Uint32 TotalPreserveAttachmentsCount  = 0;
+        CountSubpassAttachmentReferences(Desc, TotalAttachmentReferencesCount, TotalPreserveAttachmentsCount);
+        if (TotalAttachmentReferencesCount != 0)
+        {
+            m_pAttachmentReferences = ALLOCATE(GetRawAllocator(), "Memory for subpass attachment references array", AttachmentReference, TotalAttachmentReferencesCount);
+        }
+        if (TotalPreserveAttachmentsCount != 0)
+        {
+            m_pPreserveAttachments = ALLOCATE(GetRawAllocator(), "Memory for subpass preserve attachments array", Uint32, TotalPreserveAttachmentsCount);
+        }
+
+        auto* pCurrAttachmentRef      = m_pAttachmentReferences;
+        auto* pCurrPreserveAttachment = m_pPreserveAttachments;
         if (Desc.SubpassCount != 0)
         {
             auto* pSubpasses =
@@ -83,9 +97,56 @@ public:
             this->m_Desc.pSubpasses = pSubpasses;
             for (Uint32 i = 0; i < Desc.SubpassCount; ++i)
             {
-                pSubpasses[i] = Desc.pSubpasses[i];
+                const auto& SrcSubpass = Desc.pSubpasses[i];
+                auto&       DstSubpass = pSubpasses[i];
+
+                DstSubpass = SrcSubpass;
+                if (SrcSubpass.InputAttachmentCount != 0)
+                {
+                    DstSubpass.pInputAttachments = pCurrAttachmentRef;
+                    for (Uint32 input_attachment = 0; input_attachment < SrcSubpass.InputAttachmentCount; ++input_attachment)
+                        *(pCurrAttachmentRef++) = SrcSubpass.pInputAttachments[input_attachment];
+                }
+                else
+                    DstSubpass.pInputAttachments = nullptr;
+
+                if (SrcSubpass.RenderTargetAttachmentCount != 0)
+                {
+                    DstSubpass.pRenderTargetAttachments = pCurrAttachmentRef;
+                    for (Uint32 rt_attachment = 0; rt_attachment < SrcSubpass.RenderTargetAttachmentCount; ++rt_attachment)
+                        *(pCurrAttachmentRef++) = SrcSubpass.pRenderTargetAttachments[rt_attachment];
+                    if (DstSubpass.pResolveAttachments)
+                    {
+                        for (Uint32 rslv_attachment = 0; rslv_attachment < SrcSubpass.RenderTargetAttachmentCount; ++rslv_attachment)
+                            *(pCurrAttachmentRef++) = SrcSubpass.pResolveAttachments[rslv_attachment];
+                    }
+                    else
+                        DstSubpass.pResolveAttachments = nullptr;
+                }
+                else
+                {
+                    DstSubpass.pRenderTargetAttachments = nullptr;
+                    DstSubpass.pResolveAttachments      = nullptr;
+                }
+
+                if (SrcSubpass.pDepthStencilAttachment != nullptr)
+                {
+                    DstSubpass.pDepthStencilAttachment = pCurrAttachmentRef;
+                    *(pCurrAttachmentRef++)            = *SrcSubpass.pDepthStencilAttachment;
+                }
+
+                if (SrcSubpass.PreserveAttachmentCount != 0)
+                {
+                    DstSubpass.pPreserveAttachments = pCurrPreserveAttachment;
+                    for (Uint32 prsv_attachment = 0; prsv_attachment < SrcSubpass.PreserveAttachmentCount; ++prsv_attachment)
+                        *(pCurrPreserveAttachment++) = SrcSubpass.pPreserveAttachments[prsv_attachment];
+                }
+                else
+                    DstSubpass.pPreserveAttachments = nullptr;
             }
         }
+        VERIFY_EXPR(pCurrAttachmentRef - m_pAttachmentReferences == TotalAttachmentReferencesCount);
+        VERIFY_EXPR(pCurrPreserveAttachment - m_pPreserveAttachments == TotalPreserveAttachmentsCount);
 
         if (Desc.DependencyCount != 0)
         {
@@ -108,9 +169,37 @@ public:
             RawAllocator.Free(const_cast<SubpassDesc*>(this->m_Desc.pSubpasses));
         if (this->m_Desc.pDependencies != nullptr)
             RawAllocator.Free(const_cast<SubpassDependencyDesc*>(this->m_Desc.pDependencies));
+        if (m_pAttachmentReferences != nullptr)
+            RawAllocator.Free(m_pAttachmentReferences);
+        if (m_pPreserveAttachments != nullptr)
+            RawAllocator.Free(m_pPreserveAttachments);
     }
 
     IMPLEMENT_QUERY_INTERFACE_IN_PLACE(IID_RenderPass, TDeviceObjectBase)
+
+protected:
+    static void CountSubpassAttachmentReferences(const RenderPassDesc& Desc,
+                                                 Uint32&               TotalAttachmentReferencesCount,
+                                                 Uint32&               TotalPreserveAttachmentsCount)
+    {
+        TotalAttachmentReferencesCount = 0;
+        TotalPreserveAttachmentsCount  = 0;
+        for (Uint32 i = 0; i < Desc.SubpassCount; ++i)
+        {
+            const auto& Subpass = Desc.pSubpasses[i];
+            TotalAttachmentReferencesCount += Subpass.InputAttachmentCount;
+            TotalAttachmentReferencesCount += Subpass.RenderTargetAttachmentCount;
+            if (Subpass.pResolveAttachments != nullptr)
+                TotalAttachmentReferencesCount += Subpass.RenderTargetAttachmentCount;
+            if (Subpass.pDepthStencilAttachment != nullptr)
+                TotalAttachmentReferencesCount += 1;
+            TotalPreserveAttachmentsCount += Subpass.PreserveAttachmentCount;
+        }
+    }
+
+private:
+    AttachmentReference* m_pAttachmentReferences = nullptr;
+    Uint32*              m_pPreserveAttachments  = nullptr;
 };
 
 } // namespace Diligent
diff --git a/Graphics/GraphicsEngine/interface/RenderPass.h b/Graphics/GraphicsEngine/interface/RenderPass.h
index 36cfc46c..3ac3e3ce 100644
--- a/Graphics/GraphicsEngine/interface/RenderPass.h
+++ b/Graphics/GraphicsEngine/interface/RenderPass.h
@@ -124,11 +124,151 @@ struct RenderPassAttachmentDesc
 };
 typedef struct RenderPassAttachmentDesc RenderPassAttachmentDesc;
 
+#define ATTACHMENT_UNUSED (~0U)
+
+/// Attachment reference description.
+struct AttachmentReference
+{
+    /// Either an integer value identifying an attachment at the corresponding index in RenderPassDesc::pAttachments,
+    /// or ATTACHMENT_UNUSED to signify that this attachment is not used.
+    Uint32          AttachmentIndex DEFAULT_INITIALIZER(0);
+
+    /// The state of the attachment during the subpass.
+    RESOURCE_STATE  State           DEFAULT_INITIALIZER(RESOURCE_STATE_UNKNOWN);
+
+#if DILIGENT_CPP_INTERFACE
+    AttachmentReference()noexcept{}
+
+    AttachmentReference(Uint32          _AttachmentIndex,
+                        RESOURCE_STATE  _State)noexcept : 
+        AttachmentIndex{_AttachmentIndex},
+        State          {_State}
+    {}
+
+    /// Tests if two structures are equivalent
+
+    /// \param [in] RHS - reference to the structure to perform comparison with
+    /// \return 
+    /// - True if all members of the two structures are equal.
+    /// - False otherwise
+    bool operator == (const AttachmentReference& RHS) const
+    {
+        return  AttachmentIndex == RHS.AttachmentIndex &&
+                State           == RHS.State;
+    }
+
+    bool operator != (const AttachmentReference& RHS) const
+    {
+        return !(*this == RHS);
+    }
+#endif
+};
+typedef struct AttachmentReference AttachmentReference;
+
 
 /// Render pass subpass decription.
 struct SubpassDesc
 {
-    int Dummy;
+    /// The number of input attachments the subpass uses.
+    Uint32                      InputAttachmentCount        DEFAULT_INITIALIZER(0);
+
+    /// Pointer to the array of input attachments, see Diligent::AttachmentReference.
+    const AttachmentReference*  pInputAttachments           DEFAULT_INITIALIZER(nullptr);
+
+    /// The number of color render target attachments.
+    Uint32                      RenderTargetAttachmentCount DEFAULT_INITIALIZER(0);
+
+    /// Pointer to the array of color render target attachments, see Diligent::AttachmentReference.
+
+    /// Each element of the pRenderTargetAttachments array corresponds to an output in the pixel shader,
+    /// i.e. if the shader declares an output variable decorated with a render target index X, then it uses
+    /// the attachment provided in pRenderTargetAttachments[X]. If the attachment index is ATTACHMENT_UNUSED,
+    /// writes to this render target are ignored.
+    const AttachmentReference*  pRenderTargetAttachments    DEFAULT_INITIALIZER(nullptr);
+
+    /// Pointer to the array of resolve attachments, see Diligent::AttachmentReference.
+
+    /// If pResolveAttachments is not NULL, each of its elements corresponds to a render target attachment
+    /// (the element in pRenderTargetAttachments at the same index), and a multisample resolve operation is
+    /// defined for each attachment. At the end of each subpass, multisample resolve operations read the subpass's
+    /// color attachments, and resolve the samples for each pixel within the render area to the same pixel location
+    /// in the corresponding resolve attachments, unless the resolve attachment index is ATTACHMENT_UNUSED.
+    const AttachmentReference*  pResolveAttachments         DEFAULT_INITIALIZER(nullptr);
+
+    /// Pointer to the depth-stencil attachment, see Diligent::AttachmentReference.
+    const AttachmentReference*  pDepthStencilAttachment     DEFAULT_INITIALIZER(nullptr);
+
+    /// The number of preserve attachments.
+    Uint32                      PreserveAttachmentCount     DEFAULT_INITIALIZER(0);
+
+    /// Pointer to the array of preserve attachments, see Diligent::AttachmentReference.
+    const Uint32*               pPreserveAttachments        DEFAULT_INITIALIZER(nullptr);
+
+#if DILIGENT_CPP_INTERFACE
+    /// Tests if two structures are equivalent
+
+    /// \param [in] RHS - reference to the structure to perform comparison with
+    /// \return 
+    /// - True if all members of the two structures are equal.
+    /// - False otherwise
+    bool operator == (const SubpassDesc& RHS)const
+    {
+        if (InputAttachmentCount        != RHS.InputAttachmentCount ||
+            RenderTargetAttachmentCount != RHS.RenderTargetAttachmentCount ||
+            PreserveAttachmentCount     != RHS.PreserveAttachmentCount)
+            return false;
+
+        for(Uint32 i=0; i < InputAttachmentCount; ++i)
+        {
+            if (pInputAttachments[i] != RHS.pInputAttachments[i])
+                return false;
+        }
+
+        for(Uint32 i=0; i < RenderTargetAttachmentCount; ++i)
+        {
+            if (pRenderTargetAttachments[i] != RHS.pRenderTargetAttachments[i])
+                return false;
+        }
+
+        if ((pResolveAttachments == nullptr && RHS.pResolveAttachments != nullptr) ||
+            (pResolveAttachments != nullptr && RHS.pResolveAttachments == nullptr))
+            return false;
+
+        if (pResolveAttachments != nullptr && RHS.pResolveAttachments != nullptr)
+        {
+            for(Uint32 i=0; i < RenderTargetAttachmentCount; ++i)
+            {
+                if (pResolveAttachments[i] != RHS.pResolveAttachments[i])
+                    return false;
+            }
+        }
+
+        if ((pDepthStencilAttachment == nullptr && RHS.pDepthStencilAttachment != nullptr) ||
+            (pDepthStencilAttachment != nullptr && RHS.pDepthStencilAttachment == nullptr))
+            return false;
+
+        if (pDepthStencilAttachment != nullptr && RHS.pDepthStencilAttachment != nullptr)
+        {
+            if (*pDepthStencilAttachment != *RHS.pDepthStencilAttachment)
+                return false;
+        }
+
+        if ((pPreserveAttachments == nullptr && RHS.pPreserveAttachments != nullptr) ||
+            (pPreserveAttachments != nullptr && RHS.pPreserveAttachments == nullptr))
+            return false;
+
+        if (pPreserveAttachments != nullptr && RHS.pPreserveAttachments != nullptr)
+        {
+            for(Uint32 i=0; i < PreserveAttachmentCount; ++i)
+            {
+                if (pPreserveAttachments[i] != RHS.pPreserveAttachments[i])
+                    return false;
+            }
+        }
+
+        return true;
+    }
+#endif
 };
 typedef struct SubpassDesc SubpassDesc;
 
diff --git a/Graphics/GraphicsEngine/src/RenderPassBase.cpp b/Graphics/GraphicsEngine/src/RenderPassBase.cpp
index 4c4e0abd..782e950f 100644
--- a/Graphics/GraphicsEngine/src/RenderPassBase.cpp
+++ b/Graphics/GraphicsEngine/src/RenderPassBase.cpp
@@ -94,6 +94,26 @@ void ValidateRenderPassDesc(const RenderPassDesc& Desc)
             }
         }
     }
+
+    for (Uint32 i = 0; i < Desc.SubpassCount; ++i)
+    {
+        const auto& Subpass = Desc.pSubpasses[i];
+        if (Subpass.InputAttachmentCount != 0 && Subpass.pInputAttachments == nullptr)
+        {
+            LOG_RENDER_PASS_ERROR_AND_THROW("the input attachment count (", Subpass.InputAttachmentCount, ") of subpass ", i,
+                                            " is not zero, while pInputAttachments is null");
+        }
+        if (Subpass.RenderTargetAttachmentCount != 0 && Subpass.pRenderTargetAttachments == nullptr)
+        {
+            LOG_RENDER_PASS_ERROR_AND_THROW("the render target attachment count (", Subpass.RenderTargetAttachmentCount, ") of subpass ", i,
+                                            " is not zero, while pRenderTargetAttachments is null");
+        }
+        if (Subpass.PreserveAttachmentCount != 0 && Subpass.pPreserveAttachments == nullptr)
+        {
+            LOG_RENDER_PASS_ERROR_AND_THROW("the preserve attachment count (", Subpass.PreserveAttachmentCount, ") of subpass ", i,
+                                            " is not zero, while pPreserveAttachments is null");
+        }
+    }
 }
 
 } // namespace Diligent