gfx_pipeline_alpha_vulkan.hpp

// Copyright Take Vos 2022.
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt)
 
#pragma once
 
#include "gfx_pipeline_vulkan.hpp"
#include "../container/module.hpp"
#include "../macros.hpp"
#include <vma/vk_mem_alloc.h>
#include <span>
 
namespace hi { inline namespace v1 {

class gfx_pipeline_alpha : public gfx_pipeline {
public:
    struct alignas(16) vertex {
        sfloat_rgba32 position;

        sfloat_rgba32 clipping_rectangle;

        float alpha;
 
        vertex(sfloat_rgba32 position, sfloat_rgba32 clipping_rectangle, float alpha) noexcept :
            position(position), clipping_rectangle(clipping_rectangle), alpha(alpha)
        {
        }
 
        static vk::VertexInputBindingDescription inputBindingDescription()
        {
            return {0, sizeof(vertex), vk::VertexInputRate::eVertex};
        }
 
        static std::vector<vk::VertexInputAttributeDescription> inputAttributeDescriptions()
        {
            return {
                {0, 0, vk::Format::eR32G32B32A32Sfloat, offsetof(vertex, position)},
                {1, 0, vk::Format::eR32G32B32A32Sfloat, offsetof(vertex, clipping_rectangle)},
                {2, 0, vk::Format::eR32Sfloat, offsetof(vertex, alpha)},
            };
        }
    };
 
    struct push_constants {
        sfloat_rg32 windowExtent = extent2{0.0, 0.0};
        sfloat_rg32 viewportScale = scale2{0.0, 0.0};
 
        static std::vector<vk::PushConstantRange> pushConstantRanges()
        {
            return {{vk::ShaderStageFlagBits::eVertex | vk::ShaderStageFlagBits::eFragment, 0, sizeof(push_constants)}};
        }
    };
 
    struct device_shared {
        gfx_device const& device;
 
        vk::ShaderModule vertexShaderModule;
        vk::ShaderModule fragmentShaderModule;
        std::vector<vk::PipelineShaderStageCreateInfo> shaderStages;
 
        device_shared(gfx_device const& device);
        ~device_shared();
 
        device_shared(device_shared const&) = delete;
        device_shared& operator=(device_shared const&) = delete;
        device_shared(device_shared&&) = delete;
        device_shared& operator=(device_shared&&) = delete;

        void destroy(gfx_device const *vulkanDevice);
 
        void drawInCommandBuffer(vk::CommandBuffer const& commandBuffer);
 
        static void place_vertices(vector_span<vertex>& vertices, aarectangle clipping_rectangle, quad box, float alpha);
 
    private:
        void buildShaders();
        void teardownShaders(gfx_device const *vulkanDevice);
    };
 
    vector_span<vertex> vertexBufferData;
 
    ~gfx_pipeline_alpha() = default;
    gfx_pipeline_alpha(const gfx_pipeline_alpha&) = delete;
    gfx_pipeline_alpha& operator=(const gfx_pipeline_alpha&) = delete;
    gfx_pipeline_alpha(gfx_pipeline_alpha&&) = delete;
    gfx_pipeline_alpha& operator=(gfx_pipeline_alpha&&) = delete;
 
    gfx_pipeline_alpha(gfx_surface *surface) : gfx_pipeline(surface) {}
 
    void draw_in_command_buffer(vk::CommandBuffer commandBuffer, draw_context const& context) override;
 
protected:
    push_constants pushConstants;
 
    vk::Buffer vertexBuffer;
    VmaAllocation vertexBufferAllocation;
 
    [[nodiscard]] std::vector<vk::PipelineColorBlendAttachmentState> getPipelineColorBlendAttachmentStates() const override;
    [[nodiscard]] std::vector<vk::PipelineShaderStageCreateInfo> createShaderStages() const override;
    [[nodiscard]] std::vector<vk::DescriptorSetLayoutBinding> createDescriptorSetLayoutBindings() const override;
    [[nodiscard]] std::vector<vk::WriteDescriptorSet> createWriteDescriptorSet() const override;
    [[nodiscard]] size_t getDescriptorSetVersion() const override;
    [[nodiscard]] std::vector<vk::PushConstantRange> createPushConstantRanges() const override;
    [[nodiscard]] vk::VertexInputBindingDescription createVertexInputBindingDescription() const override;
    [[nodiscard]] std::vector<vk::VertexInputAttributeDescription> createVertexInputAttributeDescriptions() const override;
 
private:
    void build_vertex_buffers() override;
    void teardown_vertex_buffers() override;
};
 
}} // namespace hi::v1