Attachment.h

Go to the documentation of this file.

#ifndef VULKAN_ATTACHMENT
#define VULKAN_ATTACHMENT
 
#include <vulkan/vulkan.h>
#include <vector>
 
#include "AttachmentColorBlendingMode.h"
#include "VulkanException.h"
 
 
namespace Vulkan::PipelineOptions::RenderPassOptions {
    class AttachmentDescription; enum class PredefinedAttachment; enum class AttachmentType;
 
    template<typename T>
    concept IsAttachment = requires(T t) {
        std::same_as<T, AttachmentDescription> ||
            std::same_as < T, std::pair<AttachmentDescription, VkImageLayout>> ||
            std::same_as < T, std::pair<AttachmentDescription, AttachmentColorBlendingMode>>// && t.first.getType() == AttachmentType::COLOR) ||
            || std::same_as < T, std::tuple<AttachmentDescription, VkImageLayout, AttachmentColorBlendingMode>>;// && std::get<0>(t).getType() == AttachmentType::COLOR);
    };
 
}
 
enum class Vulkan::PipelineOptions::RenderPassOptions::PredefinedAttachment {
    STANDARD_COLOR, DEPTH
};
 
 
enum class Vulkan::PipelineOptions::RenderPassOptions::AttachmentType {
    INPUT, COLOR, DEPTH_STENCIL
};
 
 
class Vulkan::PipelineOptions::RenderPassOptions::AttachmentDescription {
    public:
 
        AttachmentDescription(PredefinedAttachment predefined = PredefinedAttachment::STANDARD_COLOR) : attachment{}, attachmentReferenceLayout{} {
            //struct for the attachment
            switch (predefined) {
            case PredefinedAttachment::STANDARD_COLOR:
                attachment.format = VK_FORMAT_B8G8R8A8_SRGB;
                attachment.samples = VK_SAMPLE_COUNT_1_BIT;
                attachment.loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR;
                attachment.storeOp = VK_ATTACHMENT_STORE_OP_STORE;
                attachment.stencilLoadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE;
                attachment.stencilStoreOp = VK_ATTACHMENT_STORE_OP_DONT_CARE;
                attachment.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
                attachment.finalLayout = VK_IMAGE_LAYOUT_PRESENT_SRC_KHR;
 
                //format reference
                attachmentReferenceLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
 
                //set type
                type = AttachmentType::COLOR;
                break;
 
            case PredefinedAttachment::DEPTH:
                attachment.format = VK_FORMAT_D32_SFLOAT;
                attachment.samples = VK_SAMPLE_COUNT_1_BIT;
                attachment.loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR;
                attachment.storeOp = VK_ATTACHMENT_STORE_OP_DONT_CARE;
                attachment.stencilLoadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE;
                attachment.stencilStoreOp = VK_ATTACHMENT_STORE_OP_DONT_CARE;
                attachment.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
                attachment.finalLayout = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL;
 
                //format reference
                attachmentReferenceLayout = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL;
 
                //set type
                type = AttachmentType::DEPTH_STENCIL;
                break;
            }
        }
 
 
        AttachmentDescription(const VkAttachmentDescription& baseAttachment, AttachmentType type, VkImageLayout referenceLayout = VK_IMAGE_LAYOUT_UNDEFINED) : attachment{ baseAttachment }, attachmentReferenceLayout{ referenceLayout }, type{ type } {}
 
 
        VkAttachmentDescription& operator+() {
            return attachment;
        }
 
 
        AttachmentType& getType() {
            return type;
        }
 
 
        VkImageLayout& getAttachmentReferenceLayout() {
            return attachmentReferenceLayout;
        }
 
 
        class BoundAttachmentDescription {
        public:
            BoundAttachmentDescription(const AttachmentDescription& attachment, int index, VkImageLayout layout, AttachmentColorBlendingMode colorBlendingMode) : 
                attachment{ attachment.attachment }, 
                attachmentReference{}, type{ attachment.type },
                colorBlendingMode{ colorBlendingMode } {
                attachmentReference.attachment = index;
                attachmentReference.layout = layout;
            }
 
 
            const VkAttachmentDescription& operator+() const {
                return attachment;
            }
 
 
            int getAttachmentReferenceIndex() const {
                return attachmentReference.attachment;
            }
 
 
            const AttachmentType& getType() const {
                return type;
            }
 
 
            const VkAttachmentReference& getAttachmentReference() const {
                return attachmentReference;
            }
 
 
            AttachmentColorBlendingMode getColorBlendingMode() const {
                if (type == AttachmentType::COLOR) {
                    return colorBlendingMode;
                }
                throw VulkanException{ "This attachment is not a color attachment, therefore it hasn't got the color blending mode" };
            }
 
        private:
            VkAttachmentDescription attachment;
            VkAttachmentReference attachmentReference;
            AttachmentType type;
            AttachmentColorBlendingMode colorBlendingMode;
        };
 
 
        template<IsAttachment... A>
        static std::vector<BoundAttachmentDescription> prepareAttachments(A... attachments) {
            std::vector<BoundAttachmentDescription> boundAttachments; //array with the attachments which must have a complete VkAttachmentReference
            
            //Put in the vector the attachment and layout to bind toghether. The right overload is called based on the type of the attachment argument (pair<AttachmentDescription, layout> or AttachmentDescription).
            std::vector<std::tuple<AttachmentDescription, VkImageLayout, AttachmentColorBlendingMode>> attachmentLayoutColorBlendingModeTriplets;       
            (attachmentLayoutColorBlendingModeTriplets.push_back(parseAttachment(attachments)), ...);
 
            //for each pair in the vector, add it to the array to return
            for (const auto& alp : attachmentLayoutColorBlendingModeTriplets) {
                boundAttachments.emplace_back(std::get<0>(alp), boundAttachments.size(), std::get<1>(alp), std::get<2>(alp)); //add the BoundAttachmentDescription to the array to return
            }
 
            return boundAttachments;
        }
 
 
    private:
 
        //These 4 functions are used to return the attachment and its respective layout, which are then used in prepareAttachments(...) to build the array to create a subpass.
        static std::tuple<AttachmentDescription, VkImageLayout, AttachmentColorBlendingMode> parseAttachment(const std::pair<AttachmentDescription, VkImageLayout>& attachment) {
            if (attachment.first.type == AttachmentType::COLOR) {
                return { attachment.first, attachment.second, AttachmentColorBlendingMode{PredefinedColorBlendingModes::STANDARD} };
            }
            return { attachment.first, attachment.second, AttachmentColorBlendingMode{} };
        }
 
        //These 4 functions are used to return the attachment and its respective layout, which are then used in prepareAttachments(...) to build the array to create a subpass.
        static std::tuple<AttachmentDescription, VkImageLayout, AttachmentColorBlendingMode> parseAttachment(const AttachmentDescription& attachment) {
            if (attachment.type == AttachmentType::COLOR) {
                return { attachment, attachment.attachmentReferenceLayout, AttachmentColorBlendingMode{PredefinedColorBlendingModes::STANDARD} };
            }
            return { attachment, attachment.attachmentReferenceLayout, AttachmentColorBlendingMode{} };
        }
 
        //These 4 functions are used to return the attachment and its respective layout, which are then used in prepareAttachments(...) to build the array to create a subpass.
        static std::tuple<AttachmentDescription, VkImageLayout, AttachmentColorBlendingMode> parseAttachment(const std::pair<AttachmentDescription, AttachmentColorBlendingMode>& attachment) {
            return { attachment.first, attachment.first.attachmentReferenceLayout, attachment.second };
        }
 
        //These 4 functions are used to return the attachment and its respective layout, which are then used in prepareAttachments(...) to build the array to create a subpass.
        static std::tuple<AttachmentDescription, VkImageLayout, AttachmentColorBlendingMode> parseAttachment(const std::tuple<AttachmentDescription, VkImageLayout, AttachmentColorBlendingMode>& attachment) {
            return attachment;
        }
 
 
        VkAttachmentDescription attachment;
        VkImageLayout attachmentReferenceLayout;
        AttachmentType type;
};
 
#endif