true_type_font.hpp

// Copyright Take Vos 2019-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 "font.hpp"
#include "../graphic_path.hpp"
#include "../resource_view.hpp"
#include "../URL.hpp"
#include "../counters.hpp"
#include "../cast.hpp"
#include <memory>
 
namespace hi::inline v1 {
 
class true_type_font final : public font {
private:
    std::optional<URL> url;
 
    mutable std::unique_ptr<resource_view> view;
 
    uint16_t OS2_x_height = 0;
    uint16_t OS2_cap_height = 0;
 
    float unitsPerEm;
    float emScale;
 
    uint16_t numberOfHMetrics;
 
    int num_glyphs;
 
public:
    true_type_font(std::unique_ptr<resource_view> view) : url(), view(std::move(view))
    {
        parse_font_directory();
    }
 
    true_type_font(URL const &url) : url(url), view(url.loadView())
    {
        ++global_counter<"ttf:map">;
        try {
            parse_font_directory();
 
            // Clear the view to reclaim resources.
            view = {};
            ++global_counter<"ttf:unmap">;
 
        } catch (std::exception const &e) {
            throw parse_error(std::format("{}: Could not parse font directory.\n{}", to_string(url), e.what()));
        }
    }
 
    true_type_font() = delete;
    true_type_font(true_type_font const &other) = delete;
    true_type_font &operator=(true_type_font const &other) = delete;
    true_type_font(true_type_font &&other) = delete;
    true_type_font &operator=(true_type_font &&other) = delete;
    ~true_type_font() = default;
 
    [[nodiscard]] bool loaded() const noexcept override
    {
        return to_bool(view);
    }
 
    [[nodiscard]] hi::glyph_id find_glyph(char32_t c) const noexcept override;
 
    std::optional<hi::glyph_id> load_glyph(hi::glyph_id glyph_id, graphic_path &path) const noexcept override;
 
    bool load_glyph_metrics(hi::glyph_id glyph_id, glyph_metrics &metrics, hi::glyph_id lookahead_glyph_id = hi::glyph_id{})
        const noexcept override;
 
    [[nodiscard]] vector2 get_kerning(hi::glyph_id current_glyph, hi::glyph_id next_glyph) const noexcept override;
 
    virtual void substitution_and_kerning(iso_639 language, iso_15924 script, std::vector<substitution_and_kerning_type> &word)
        const noexcept override
    {
    }
 
private:
    mutable std::span<std::byte const> _cmap_table_bytes;
    mutable std::span<std::byte const> _cmap_bytes;
    mutable std::span<std::byte const> _loca_table_bytes;
    mutable std::span<std::byte const> _glyf_table_bytes;
    mutable std::span<std::byte const> _hmtx_table_bytes;
    mutable std::span<std::byte const> _kern_table_bytes;
    mutable std::span<std::byte const> _GSUB_table_bytes;
    bool _loca_table_is_offset32;
 
    void cache_tables() const noexcept
    {
        _cmap_table_bytes = get_table_bytes("cmap");
        _cmap_bytes = parse_cmap_table_directory();
        _loca_table_bytes = get_table_bytes("loca");
        _glyf_table_bytes = get_table_bytes("glyf");
        _hmtx_table_bytes = get_table_bytes("hmtx");
 
        // Optional tables.
        _kern_table_bytes = get_table_bytes("kern");
        _GSUB_table_bytes = get_table_bytes("GSUB");
    }
 
    void load_view() const noexcept
    {
        if (view) {
            [[likely]] return;
        }
 
        hi_axiom(url);
        view = url->loadView();
        ++global_counter<"ttf:map">;
        cache_tables();
    }
 
    [[nodiscard]] std::span<std::byte const> get_table_bytes(char const *table_name) const;
 
    void parse_font_directory();
 
    void parse_head_table(std::span<std::byte const> headTableBytes);
    void parse_hhea_table(std::span<std::byte const> bytes);
    void parse_name_table(std::span<std::byte const> bytes);
    void parse_OS2_table(std::span<std::byte const> bytes);
    void parse_maxp_table(std::span<std::byte const> bytes);
 
    [[nodiscard]] std::span<std::byte const> parse_cmap_table_directory() const;
 
    [[nodiscard]] hi::unicode_mask parse_cmap_table_mask() const;
 
    bool get_glyf_bytes(hi::glyph_id glyph_id, std::span<std::byte const> &bytes) const noexcept;
 
    bool update_glyph_metrics(
        hi::glyph_id glyph_id,
        glyph_metrics &metrics,
        hi::glyph_id kern_glyph1_id = hi::glyph_id{},
        hi::glyph_id kern_glyph2_id = hi::glyph_id{}) const noexcept;
 
    bool load_simple_glyph(std::span<std::byte const> bytes, graphic_path &glyph) const noexcept;
 
    bool
    load_compound_glyph(std::span<std::byte const> bytes, graphic_path &glyph, hi::glyph_id &metrics_glyph_id) const noexcept;
 
    bool load_compound_glyph_metrics(std::span<std::byte const> bytes, hi::glyph_id &metrics_glyph_id) const noexcept;
 
    [[nodiscard]] std::ptrdiff_t get_coverage_index(std::span<std::byte const> bytes, hi::glyph_id glyph) noexcept;
};
 
} // namespace hi::inline v1