gfx_pipeline_override_vulkan_intf.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_intf.hpp"
#include "../container/container.hpp"
#include "../image/image.hpp"
#include "../color/color.hpp"
#include "../geometry/geometry.hpp"
#include "../macros.hpp"
#include <vma/vk_mem_alloc.h>
#include <vulkan/vulkan.hpp>
#include <span>
#include <vector>
 
hi_export_module(hikogui.GFX : gfx_pipeline_override_intf);
 
hi_export namespace hi { inline namespace v1 {
 
class gfx_pipeline_override : public gfx_pipeline {
public:
    struct alignas(16) vertex {
        sfloat_rgba32 position;
 
        sfloat_rgba32 clipping_rectangle;
 
        sfloat_rgba16 color;
 
        sfloat_rgba16 blend_factor;
 
        vertex(sfloat_rgba32 position, sfloat_rgba32 clipping_rectangle, sfloat_rgba16 color, sfloat_rgba16 blend_factor) noexcept :
            position(position), clipping_rectangle(clipping_rectangle), color(color), blend_factor(blend_factor)
        {
        }
 
        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::eR16G16B16A16Sfloat, offsetof(vertex, color)},
                {3, 0, vk::Format::eR16G16B16A16Sfloat, offsetof(vertex, blend_factor)},
            };
        }
    };
 
    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, quad_color color, quad_color blend_factor);
 
    private:
        void buildShaders();
        void teardownShaders(gfx_device const *vulkanDevice);
    };
 
    vector_span<vertex> vertexBufferData;
 
    ~gfx_pipeline_override() = default;
    gfx_pipeline_override(const gfx_pipeline_override&) = delete;
    gfx_pipeline_override& operator=(const gfx_pipeline_override&) = delete;
    gfx_pipeline_override(gfx_pipeline_override&&) = delete;
    gfx_pipeline_override& operator=(gfx_pipeline_override&&) = delete;
 
    gfx_pipeline_override(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