pipeline_image_device_shared.hpp

// Copyright Take Vos 2019-2020.
// 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 "pipeline_image_texture_map.hpp"
#include "pipeline_image_vertex.hpp"
#include "paged_image.hpp"
#include "../required.hpp"
#include "../rapid/sfloat_rgba16.hpp"
#include "../geometry/quad.hpp"
#include "../vector_span.hpp"
#include <vma/vk_mem_alloc.h>
#include <vulkan/vulkan.hpp>
#include <mutex>
 
namespace hi::inline v1 {
class gfx_device_vulkan;
template<typename T>
class pixel_map;
 
namespace pipeline_image {
 
struct device_shared {
    static constexpr std::size_t atlas_num_pages_per_axis = 8;
    static constexpr std::size_t atlas_num_pages_per_image = atlas_num_pages_per_axis * atlas_num_pages_per_axis;
    static constexpr std::size_t atlas_image_axis_size = atlas_num_pages_per_axis * (paged_image::page_size + 2);
    static constexpr std::size_t atlas_maximum_num_images = 64;
    static constexpr std::size_t staging_image_width = 1024;
    static constexpr std::size_t staging_image_height = 1024;
 
    gfx_device_vulkan const &device;
 
    vk::ShaderModule vertex_shader_module;
    vk::ShaderModule fragment_shader_module;
    std::vector<vk::PipelineShaderStageCreateInfo> shader_stages;
 
    texture_map staging_texture;
    std::vector<texture_map> atlas_textures;
 
    std::array<vk::DescriptorImageInfo, atlas_maximum_num_images> atlas_descriptor_image_infos;
    vk::Sampler atlas_sampler;
    vk::DescriptorImageInfo atlas_sampler_descriptor_image_info;
 
    device_shared(gfx_device_vulkan 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_vulkan *vulkanDevice);
 
    std::vector<std::size_t> allocate_pages(std::size_t num_pages) noexcept;
 
    void free_pages(std::vector<std::size_t> const &pages) noexcept;
 
    void draw_in_command_buffer(vk::CommandBuffer &commandBuffer);
 
    hi::pixel_map<sfloat_rgba16> get_staging_pixel_map();
 
    void prepare_atlas_for_rendering();
 
    void place_vertices(
        vector_span<vertex> &vertices,
        aarectangle const &clipping_rectangle,
        quad const &box,
        paged_image const &image) noexcept;
 
private:
    std::vector<std::size_t> _atlas_free_pages;
 
    hi::pixel_map<sfloat_rgba16> get_staging_pixel_map(std::size_t width, std::size_t height)
    {
        return get_staging_pixel_map().submap(0, 0, width, height);
    }
 
    void make_staging_border_transparent(aarectangle border_rectangle) noexcept;
 
    void clear_staging_between_border_and_upload(aarectangle border_rectangle, aarectangle upload_rectangle) noexcept;
 
    void prepare_staging_for_upload(paged_image const &image) noexcept;
 
    void update_atlas_with_staging_pixel_map(paged_image const &image) noexcept;
 
    void build_shaders();
    void teardown_shaders(gfx_device_vulkan *vulkan_device);
    void add_atlas_image();
    void build_atlas();
    void teardown_atlas(gfx_device_vulkan *vulkan_device);
 
    friend paged_image;
};
 
} // namespace pipeline_image
} // namespace hi::inline v1