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 "font_char_map.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 "../lean_vector.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;
 
    font_char_map char_map;
 
    std::string features;
 
    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]] glyph_id find_glyph(char32_t c) const noexcept
    {
        return char_map.find(c);
    }
 
    [[nodiscard]] lean_vector<glyph_id> find_glyph(grapheme g) const;
 
    [[nodiscard]] virtual graphic_path get_path(hi::glyph_id glyph_id) const = 0;
 
    [[nodiscard]] virtual float get_advance(hi::glyph_id glyph_id) const = 0;
 
    [[nodiscard]] virtual glyph_metrics get_metrics(hi::glyph_id glyph_id) const = 0;
 
    struct shape_run_result_type {
        std::vector<float> grapheme_advances;
 
        std::vector<size_t> glyph_count;
 
        std::vector<glyph_id> glyphs;
 
        std::vector<point2> glyph_positions;
 
        std::vector<aarectangle> glyph_bounding_rectangles;
 
        void reserve(size_t count) noexcept
        {
            grapheme_advances.reserve(count);
            glyph_count.reserve(count);
            glyphs.reserve(count);
            glyph_positions.reserve(count);
            glyph_bounding_rectangles.reserve(count);
        }
 
        void scale(float s) noexcept
        {
            auto M = scale2{s};
            for (auto& tmp : grapheme_advances) {
                tmp = s * tmp;
            }
            for (auto& tmp : glyph_positions) {
                tmp = M * tmp;
            }
            for (auto& tmp : glyph_bounding_rectangles) {
                tmp = M * tmp;
            }
        }
    };
 
    [[nodiscard]] virtual shape_run_result_type shape_run(iso_639 language, iso_15924 script, gstring run) 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);
    }
};