Font.hpp

Go to the documentation of this file.

#ifndef DONUT_GRAPHICS_FONT_HPP
#define DONUT_GRAPHICS_FONT_HPP
 
#include <donut/AtlasPacker.hpp>
#include <donut/Filesystem.hpp>
#include <donut/UniqueHandle.hpp>
#include <donut/graphics/Texture.hpp>
#include <donut/math.hpp>
 
#include <cstddef> // std::size_t, std::byte
#include <utility> // std::pair
#include <vector>  // std::vector
 
namespace donut::graphics {
 
class Renderer; // Forward declaration, to avoid including Renderer.hpp.
 
struct FontOptions {
    bool useLinearFiltering = false;
};
 
class Font {
public:
    struct Glyph {
        vec2 positionInAtlas; 
        vec2 sizeInAtlas;     
        bool rendered;        
    };
 
    struct GlyphMetrics {
        vec2 size;     
        vec2 bearing;  
        float advance; 
    };
 
    struct LineMetrics {
        float ascender;  
        float descender; 
        float height;    
    };
 
    Font(const Filesystem& filesystem, const char* filepath, const FontOptions& options = {});
 
    ~Font() = default;
 
    Font(const Font&) = delete;
 
    Font(Font&& other) noexcept = default;
 
    Font& operator=(const Font& other) = delete;
 
    Font& operator=(Font&& other) noexcept = default;
 
    [[nodiscard]] Glyph findGlyph(u32 characterSize, char32_t codePoint) const noexcept;
 
    std::pair<Glyph, bool> renderGlyph(Renderer& renderer, u32 characterSize, char32_t codePoint);
 
    [[nodiscard]] GlyphMetrics getGlyphMetrics(u32 characterSize, char32_t codePoint) const noexcept;
 
    [[nodiscard]] LineMetrics getLineMetrics(u32 characterSize) const noexcept;
 
    [[nodiscard]] vec2 getKerning(u32 characterSize, char32_t left, char32_t right) const noexcept;
 
    void markGlyphForRendering(u32 characterSize, char32_t codePoint);
 
    bool renderMarkedGlyphs(Renderer& renderer);
 
    [[nodiscard]] bool containsGlyphsMarkedForRendering() const noexcept;
 
    [[nodiscard]] const Texture& getAtlasTexture() const noexcept {
        return atlasTexture;
    }
 
private:
    struct FontDeleter {
        void operator()(void* handle) const noexcept;
    };
 
    struct GlyphKey {
        u32 characterSize;
        char32_t codePoint;
 
        [[nodiscard]] constexpr auto operator<=>(const GlyphKey&) const = default;
    };
 
    static constexpr std::size_t INITIAL_RESOLUTION = 128;
    static constexpr std::size_t PADDING = 6;
 
    void prepareAtlasTexture(Renderer& renderer, bool resized);
 
    std::vector<std::byte> fontFileContents;
    UniqueHandle<void*, FontDeleter> font;
    AtlasPacker<INITIAL_RESOLUTION, PADDING> atlasPacker{};
    Texture atlasTexture{};
    std::vector<GlyphKey> sortedGlyphKeys{};
    std::vector<Glyph> glyphsSortedByKey{};
    std::vector<GlyphKey> glyphKeysMarkedForRendering{};
    FontOptions options;
};
 
} // namespace donut::graphics
 
#endif