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_page.hpp"
#include "../required.hpp"
#include "../rapid/sfloat_rgba16.hpp"
#include <vk_mem_alloc.h>
#include <vulkan/vulkan.hpp>
#include <mutex>
 
namespace tt {
class gfx_device_vulkan;
template<typename T> class pixel_map;
}
 
namespace tt::pipeline_image {
 
struct image;
 
struct device_shared final {
    static constexpr int atlasNrHorizontalPages = 16;
    static constexpr int atlasNrVerticalPages = 16;
    static constexpr int atlasImageWidth = atlasNrHorizontalPages * Page::widthIncludingBorder;
    static constexpr int atlasImageHeight = atlasNrVerticalPages * Page::heightIncludingBorder;
    static constexpr int atlasNrPagesPerImage = atlasNrHorizontalPages * atlasNrVerticalPages;
    static constexpr int atlasMaximumNrImages = 16;
    static constexpr int stagingImageWidth = 1024;
    static constexpr int stagingImageHeight = 1024;
 
    gfx_device_vulkan const &device;
 
    vk::ShaderModule vertexShaderModule;
    vk::ShaderModule fragmentShaderModule;
    std::vector<vk::PipelineShaderStageCreateInfo> shaderStages;
 
    texture_map stagingTexture;
    std::vector<texture_map> atlasTextures;
 
    std::array<vk::DescriptorImageInfo, atlasMaximumNrImages> atlasDescriptorImageInfos;
    vk::Sampler atlasSampler;
    vk::DescriptorImageInfo atlasSamplerDescriptorImageInfo;
 
    std::vector<Page> atlasFreePages;
 
    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);
 
    static point3 getAtlasPositionFromPage(Page page) noexcept {
        ttlet imageIndex = page.nr / atlasNrPagesPerImage;
        ttlet pageNrInsideImage = page.nr % atlasNrPagesPerImage;
 
        ttlet pageY = pageNrInsideImage / atlasNrVerticalPages;
        ttlet pageX = pageNrInsideImage % atlasNrVerticalPages;
 
        ttlet x = pageX * Page::widthIncludingBorder + Page::border;
        ttlet y = pageY * Page::heightIncludingBorder + Page::border;
 
        return point3{narrow_cast<float>(x), narrow_cast<float>(y), narrow_cast<float>(imageIndex)};
    }
 
    std::vector<Page> allocatePages(size_t num_pages) noexcept;
 
    void freePages(std::vector<Page> const &pages) noexcept;
 
    image makeImage(size_t width, size_t height) noexcept;
 
    void drawInCommandBuffer(vk::CommandBuffer &commandBuffer);
 
    tt::pixel_map<sfloat_rgba16> getStagingPixelMap();
 
    void prepareAtlasForRendering();
 
private:
    tt::pixel_map<sfloat_rgba16> getStagingPixelMap(size_t width, size_t height) {
        return getStagingPixelMap().submap(0, 0, width, height);
    }
 
    void updateAtlasWithStagingPixelMap(image const &image);
 
    void buildShaders();
    void teardownShaders(gfx_device_vulkan *vulkanDevice);
    void addAtlasImage();
    void buildAtlas();
    void teardownAtlas(gfx_device_vulkan *vulkanDevice);
 
    friend image;
};
 
}