font.hpp

// Copyright Take Vos 2019-2022.
// 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 "glyph_metrics.hpp"
#include "glyph_atlas_info.hpp"
#include "glyph_ids.hpp"
#include "font_weight.hpp"
#include "font_variant.hpp"
#include "font_metrics.hpp"
#include "../unicode/unicode_mask.hpp"
#include "../unicode/gstring.hpp"
#include "../i18n/iso_15924.hpp"
#include "../i18n/iso_639.hpp"
#include "../graphic_path.hpp"
#include "../utility/module.hpp"
#include "../hash_map.hpp"
#include <span>
#include <vector>
#include <map>
#include <string>
 
namespace hi::inline v1 {
 
class font {
public:
    std::string family_name;
 
    std::string sub_family_name;
 
    bool monospace = false;
    bool serif = false;
    bool italic = false;
    bool condensed = false;
    font_weight weight = font_weight::Regular;
    float optical_size = 12.0;
 
    std::string features;
 
    hi::unicode_mask unicode_mask;
 
    hi::font_metrics metrics;
 
    std::vector<hi::font *> fallback_chain;
 
    font() = default;
    virtual ~font() = default;
    font(font const &) = delete;
    font &operator=(font const &) = delete;
    font(font &&) = delete;
    font &operator=(font &&) = delete;
 
    [[nodiscard]] virtual bool loaded() const noexcept = 0;
 
    [[nodiscard]] virtual hi::glyph_id find_glyph(char32_t c) const = 0;
 
    [[nodiscard]] hi::glyph_ids find_glyph(grapheme g) const;
 
    virtual std::optional<hi::glyph_id> load_glyph(hi::glyph_id glyph_id, graphic_path &path) const = 0;
 
    virtual bool load_glyph_metrics(
        hi::glyph_id glyph_id,
        glyph_metrics &metrics,
        hi::glyph_id lookahead_glyph_id = hi::glyph_id{}) const = 0;
 
    [[nodiscard]] virtual vector2 get_kerning(hi::glyph_id current_glyph, hi::glyph_id next_glyph) const = 0;
 
    struct substitution_and_kerning_type {
        glyph_id glyph;
 
        vector2 advance;
    };
 
    virtual void substitution_and_kerning(iso_639 language, iso_15924 script, std::vector<substitution_and_kerning_type> &word)
        const = 0;
 
    glyph_atlas_info &atlas_info(glyph_ids const &glyphs) const
    {
        if (glyphs.has_num_glyphs<1>()) [[likely]] {
            hilet index = static_cast<std::size_t>(get<0>(glyphs));
            if (index >= _single_glyph_atlas_table.size()) [[unlikely]] {
                _single_glyph_atlas_table.resize(index + 1);
            }
            return _single_glyph_atlas_table[index];
 
        } else {
            return _multi_glyph_atlas_table[glyphs];
        }
    }
 
    [[nodiscard]] font_variant font_variant() const noexcept
    {
        return {weight, italic};
    }
 
    [[nodiscard]] friend std::string to_string(font const &rhs) noexcept
    {
        return std::format(
            "{} - {}: style={}{}{}{}{}{}, features={}",
            rhs.family_name,
            rhs.sub_family_name,
            rhs.monospace ? 'M' : '_',
            rhs.serif ? 'S' : '_',
            rhs.italic ? 'I' : '_',
            rhs.condensed ? 'C' : '_',
            to_char(rhs.weight),
            rhs.optical_size,
            rhs.features);
    }
 
private:
    mutable std::vector<glyph_atlas_info> _single_glyph_atlas_table;
    mutable hash_map<glyph_ids, glyph_atlas_info> _multi_glyph_atlas_table;
};
 
} // namespace hi::inline v1
 
template<typename CharT>
struct std::formatter<hi::font, CharT> : formatter<std::string_view, CharT> {
    auto format(hi::font const &t, auto &fc)
    {
        return formatter<string_view, CharT>::format(to_string(t), fc);
    }
};