PipelineSDF_DeviceShared.hpp

// Copyright 2019 Pokitec
// All rights reserved.
 
#pragma once
 
#include "TTauri/GUI/PipelineSDF_TextureMap.hpp"
#include "TTauri/GUI/PipelineSDF_AtlasRect.hpp"
#include "TTauri/GUI/PipelineSDF_SpecializationConstants.hpp"
#include "TTauri/GUI/GUIDevice_forward.hpp"
#include "TTauri/Text/FontGlyphIDs.hpp"
#include "TTauri/Foundation/required.hpp"
#include "TTauri/Foundation/logger.hpp"
#include "TTauri/Foundation/vspan.hpp"
#include "TTauri/Foundation/ivec.hpp"
#include "TTauri/Foundation/rect.hpp"
#include <vma/vk_mem_alloc.h>
#include <vulkan/vulkan.hpp>
#include <mutex>
#include <unordered_map>
 
namespace tt {
template<typename T> struct PixelMap;
class vec;
class mat;
}
 
namespace tt {
class ShapedText;
struct AttributedGlyph;
}
 
namespace tt::PipelineSDF {
 
struct Image;
struct Vertex;
 
struct DeviceShared 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 = SDF8::max_distance;
    static constexpr float scaledDrawBorder = drawBorder / drawFontSize;
 
    GUIDevice const &device;
 
    vk::ShaderModule vertexShaderModule;
    vk::ShaderModule fragmentShaderModule;
 
    SpecializationConstants specializationConstants;
    std::vector<vk::SpecializationMapEntry> fragmentShaderSpecializationMapEntries;
    vk::SpecializationInfo fragmentShaderSpecializationInfo;
    std::vector<vk::PipelineShaderStageCreateInfo> shaderStages;
 
    std::unordered_map<FontGlyphIDs,AtlasRect> glyphs_in_atlas;
    TextureMap stagingTexture;
    std::vector<TextureMap> atlasTextures;
 
    std::array<vk::DescriptorImageInfo, atlasMaximumNrImages> atlasDescriptorImageInfos;
    vk::Sampler atlasSampler;
    vk::DescriptorImageInfo atlasSamplerDescriptorImageInfo;
 
    ivec atlasAllocationPosition = {};
    int atlasAllocationMaxHeight = 0;
 
 
    DeviceShared(GUIDevice const &device);
    ~DeviceShared();
 
    DeviceShared(DeviceShared const &) = delete;
    DeviceShared &operator=(DeviceShared const &) = delete;
    DeviceShared(DeviceShared &&) = delete;
    DeviceShared &operator=(DeviceShared &&) = delete;
 
    void destroy(GUIDevice *vulkanDevice);
 
    [[nodiscard]] AtlasRect allocateRect(vec drawExtent) noexcept;
 
    void drawInCommandBuffer(vk::CommandBuffer &commandBuffer);
 
    void uploadStagingPixmapToAtlas(AtlasRect location);
 
    void prepareStagingPixmapForDrawing();
 
    void prepareAtlasForRendering();
 
    void prepareAtlas(ShapedText const &text) noexcept;
 
    static aarect getBoundingBox(FontGlyphIDs const &glyphs) noexcept;
    
    void placeVertices(vspan<Vertex> &vertices, FontGlyphIDs const &glyphs, rect box, vec color, aarect clippingRectangle) noexcept;
 
    void placeVertices(vspan<Vertex> &vertices, ShapedText const &text, mat transform, aarect clippingRectangle) noexcept;
 
    void placeVertices(vspan<Vertex> &vertices, ShapedText const &text, mat transform, aarect clippingRectangle, vec color) noexcept;
 
private:
    void buildShaders();
    void teardownShaders(GUIDevice_vulkan *vulkanDevice);
    void addAtlasImage();
    void buildAtlas();
    void teardownAtlas(GUIDevice_vulkan *vulkanDevice);
 
    [[nodiscard]] bool _placeVertices(vspan<Vertex> &vertices, FontGlyphIDs const &glyphs, rect box, vec color, aarect clippingRectangle) noexcept;
 
    [[nodiscard]] bool _placeVertices(vspan<Vertex> &vertices, AttributedGlyph const &attr_glyph, mat transform, aarect clippingRectangle) noexcept;
 
    [[nodiscard]] bool _placeVertices(vspan<Vertex> &vertices, AttributedGlyph const &attr_glyph, mat transform, aarect clippingRectangle, vec color) noexcept;
 
    AtlasRect addGlyphToAtlas(FontGlyphIDs glyph) noexcept;
 
    std::pair<AtlasRect,bool> getGlyphFromAtlas(FontGlyphIDs glyph) noexcept;
 
};
 
}