pipeline_SDF_device_shared.hpp

// Copyright Take Vos 2020-2021.
// 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_SDF_texture_map.hpp"
#include "pipeline_SDF_atlas_rect.hpp"
#include "pipeline_SDF_specialization_constants.hpp"
#include "../text/font_glyph_ids.hpp"
#include "../required.hpp"
#include "../log.hpp"
#include "../vspan.hpp"
#include "../geometry/rectangle.hpp"
#include <vk_mem_alloc.h>
#include <vulkan/vulkan.hpp>
#include <mutex>
#include <unordered_map>
 
namespace tt {
class gfx_device_vulkan;
template<typename T>
class pixel_map;
class mat;
} // namespace tt
 
namespace tt {
class shaped_text;
struct attributed_glyph;
} // namespace tt
 
namespace tt::pipeline_SDF {
 
struct Image;
struct vertex;
 
struct device_shared final {
    // Studies in China have shown that literate individuals know and use between 3,000 and 4,000 characters.
    // Handle up to 4096 characters with a 16 x 1024 x 1024, 16 x 1 MByte
    static constexpr int atlasImageWidth = 1024; // 16 characters, of 64 pixels wide.
    static constexpr int atlasImageHeight = 1024; // 16 characters, of 64 pixels height.
    static_assert(atlasImageWidth == atlasImageHeight, "needed for fwidth(textureCoord)");
 
    static constexpr int atlasMaximumNrImages = 16; // 16 * 512 characters, of 64x64 pixels.
    static constexpr int stagingImageWidth = 128; // maximum size of character that can be uploaded is 128x128
    static constexpr int stagingImageHeight = 128;
 
    static constexpr float atlasTextureCoordinateMultiplier = 1.0f / atlasImageWidth;
    static constexpr float drawfontSize = 28.0f;
    static constexpr float drawBorder = sdf_r8::max_distance;
    static constexpr float scaledDrawBorder = drawBorder / drawfontSize;
 
    gfx_device_vulkan const &device;
 
    vk::ShaderModule vertexShaderModule;
    vk::ShaderModule fragmentShaderModule;
 
    specialization_constants specializationConstants;
    std::vector<vk::SpecializationMapEntry> fragmentShaderSpecializationMapEntries;
    vk::SpecializationInfo fragmentShaderSpecializationInfo;
    std::vector<vk::PipelineShaderStageCreateInfo> shaderStages;
 
    std::unordered_map<font_glyph_ids, atlas_rect> glyphs_in_atlas;
    texture_map stagingTexture;
    std::vector<texture_map> atlasTextures;
 
    std::array<vk::DescriptorImageInfo, atlasMaximumNrImages> atlasDescriptorImageInfos;
    vk::Sampler atlasSampler;
    vk::DescriptorImageInfo atlasSamplerDescriptorImageInfo;
 
    point3 atlas_allocation_position = {};
    int atlasAllocationMaxHeight = 0;
 
    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);
 
    [[nodiscard]] atlas_rect allocateRect(extent2 drawExtent) noexcept;
 
    void drawInCommandBuffer(vk::CommandBuffer &commandBuffer);
 
    void uploadStagingPixmapToAtlas(atlas_rect location);
 
    void prepareStagingPixmapForDrawing();
 
    void prepareAtlasForRendering();
 
    void prepareAtlas(shaped_text const &text) noexcept;
 
    aarectangle get_bounding_box(font_glyph_ids const &glyphs) const noexcept;
 
    void place_vertices(
        vspan<vertex> &vertices,
        aarectangle clipping_rectangle,
        rectangle box,
        font_glyph_ids const &glyphs,
        float glyph_size,
        color color) noexcept;
 
    void place_vertices(
        vspan<vertex> &vertices,
        aarectangle clipping_rectangle,
        matrix3 transform,
        shaped_text const &text) noexcept;
 
    void place_vertices(
        vspan<vertex> &vertices,
        aarectangle clipping_rectangle,
        matrix3 transform,
        shaped_text const &text,
        color color) noexcept;
 
private:
    void buildShaders();
    void teardownShaders(gfx_device_vulkan *vulkanDevice);
    void addAtlasImage();
    void buildAtlas();
    void teardownAtlas(gfx_device_vulkan *vulkanDevice);
 
    [[nodiscard]] bool _place_vertices(
        vspan<vertex> &vertices,
        aarectangle clipping_rectangle,
        rectangle box,
        font_glyph_ids const &glyphs,
        color color
        ) noexcept;
 
    [[nodiscard]] bool _place_vertices(
        vspan<vertex> &vertices,
        aarectangle clippingRectangle,
        matrix3 transform,
        attributed_glyph const &attr_glyph
        ) noexcept;
 
    [[nodiscard]] bool _place_vertices(
        vspan<vertex> &vertices,
        aarectangle clippingRectangle,
        matrix3 transform,
        attributed_glyph const &attr_glyph,
        color color) noexcept;
 
    atlas_rect add_glyph_to_atlas(font_glyph_ids glyph) noexcept;
 
    std::pair<atlas_rect, bool> get_glyph_from_atlas(font_glyph_ids glyph) noexcept;
};
 
} // namespace tt::pipeline_SDF