From 200828276e0f37bfd46068ea5dc5f03ebb2e1552 Mon Sep 17 00:00:00 2001 From: bruvzg <7645683+bruvzg@users.noreply.github.com> Date: Tue, 11 Aug 2020 12:11:28 +0300 Subject: [Complex Text Layouts] Implement ICU / HarfBuzz based TextServer module. --- modules/text_server_adv/SCsub | 85 +- modules/text_server_adv/bitmap_font_adv.cpp | 575 ++++++ modules/text_server_adv/bitmap_font_adv.h | 115 ++ modules/text_server_adv/config.py | 3 +- modules/text_server_adv/dynamic_font_adv.cpp | 973 ++++++++++ modules/text_server_adv/dynamic_font_adv.h | 188 ++ modules/text_server_adv/font_adv.h | 90 + modules/text_server_adv/register_types.cpp | 43 + modules/text_server_adv/register_types.h | 40 + modules/text_server_adv/script_iterator.cpp | 109 ++ modules/text_server_adv/script_iterator.h | 61 + modules/text_server_adv/text_server_adv.cpp | 2520 ++++++++++++++++++++++++++ modules/text_server_adv/text_server_adv.h | 244 +++ 13 files changed, 5039 insertions(+), 7 deletions(-) create mode 100644 modules/text_server_adv/bitmap_font_adv.cpp create mode 100644 modules/text_server_adv/bitmap_font_adv.h create mode 100644 modules/text_server_adv/dynamic_font_adv.cpp create mode 100644 modules/text_server_adv/dynamic_font_adv.h create mode 100644 modules/text_server_adv/font_adv.h create mode 100644 modules/text_server_adv/register_types.cpp create mode 100644 modules/text_server_adv/register_types.h create mode 100644 modules/text_server_adv/script_iterator.cpp create mode 100644 modules/text_server_adv/script_iterator.h create mode 100644 modules/text_server_adv/text_server_adv.cpp create mode 100644 modules/text_server_adv/text_server_adv.h diff --git a/modules/text_server_adv/SCsub b/modules/text_server_adv/SCsub index 819ae4f4da..b4a8450f94 100644 --- a/modules/text_server_adv/SCsub +++ b/modules/text_server_adv/SCsub @@ -3,6 +3,38 @@ Import("env") Import("env_modules") +env_text_server_adv = env_modules.Clone() + + +def make_icu_data(target, source, env): + import os + + dst = target[0].srcnode().abspath + + g = open(dst, "w", encoding="utf-8") + + g.write("/* THIS FILE IS GENERATED DO NOT EDIT */\n") + g.write("/* (C) 2016 and later: Unicode, Inc. and others. */\n") + g.write("/* License & terms of use: http://www.unicode.org/copyright.html */\n") + g.write("#ifndef _ICU_DATA_H\n") + g.write("#define _ICU_DATA_H\n") + g.write('#include "unicode/utypes.h"\n') + g.write('#include "unicode/udata.h"\n') + g.write('#include "unicode/uversion.h"\n') + + f = open(source[0].srcnode().abspath, "rb") + buf = f.read() + import os.path + + g.write('extern "C" U_EXPORT const size_t U_ICUDATA_SIZE = ' + str(len(buf)) + ";\n") + g.write('extern "C" U_EXPORT const unsigned char U_ICUDATA_ENTRY_POINT[] = {\n') + for i in range(len(buf)): + g.write("\t" + str(buf[i]) + ",\n") + + g.write("};\n") + g.write("#endif") + + if env["builtin_harfbuzz"]: env_harfbuzz = env_modules.Clone() @@ -93,7 +125,13 @@ if env["builtin_harfbuzz"]: ] ) env_harfbuzz.Append( - CCFLAGS=["-DHAVE_ICU_BUILTIN", "-DHAVE_ICU", "-DHAVE_FREETYPE", "-DHAVE_GRAPHITE2", "-DGRAPHITE2_STATIC",] + CCFLAGS=[ + "-DHAVE_ICU_BUILTIN", + "-DHAVE_ICU", + "-DHAVE_FREETYPE", + "-DHAVE_GRAPHITE2", + "-DGRAPHITE2_STATIC", + ] ) env_harfbuzz.disable_warnings() env_thirdparty = env_harfbuzz.Clone() @@ -158,7 +196,13 @@ if env["builtin_graphite"]: thirdparty_sources = [thirdparty_dir + file for file in thirdparty_sources] env_graphite.Append(CPPPATH=["#thirdparty/graphite/src", "#thirdparty/graphite/include"]) - env_graphite.Append(CCFLAGS=["-DGRAPHITE2_STATIC", "-DGRAPHITE2_NTRACING", "-DGRAPHITE2_NFILEFACE"]) + env_graphite.Append( + CCFLAGS=[ + "-DGRAPHITE2_STATIC", + "-DGRAPHITE2_NTRACING", + "-DGRAPHITE2_NFILEFACE", + ] + ) env_graphite.disable_warnings() env_thirdparty = env_graphite.Clone() env_thirdparty.disable_warnings() @@ -353,7 +397,7 @@ if env["builtin_icu"]: "common/uset.cpp", "common/uset_props.cpp", "common/usetiter.cpp", - "common/ushape.cpp", + # "common/ushape.cpp", "common/usprep.cpp", "common/ustack.cpp", "common/ustr_cnv.cpp", @@ -382,12 +426,39 @@ if env["builtin_icu"]: "common/wintz.cpp", ] thirdparty_sources = [thirdparty_dir + file for file in thirdparty_sources] - thirdparty_sources += ["icu_data/icudata_stub.cpp"] + + icu_data_name = "icudt68l.dat" + + if env_icu["tools"]: + env_icu.Depends("#thirdparty/icu4c/icudata.gen.h", "#thirdparty/icu4c/" + icu_data_name) + env_icu.Command("#thirdparty/icu4c/icudata.gen.h", "#thirdparty/icu4c/" + icu_data_name, make_icu_data) + else: + thirdparty_sources += ["icu_data/icudata_stub.cpp"] env_icu.Append(CPPPATH=["#thirdparty/icu4c/common/"]) env_icu.Append( - CXXFLAGS=["-DU_STATIC_IMPLEMENTATION", "-DU_COMMON_IMPLEMENTATION", "-DPKGDATA_MODE=static",] + CXXFLAGS=[ + "-DU_STATIC_IMPLEMENTATION", + "-DU_COMMON_IMPLEMENTATION", + "-DUCONFIG_NO_COLLATION", + "-DUCONFIG_NO_CONVERSION", + "-DUCONFIG_NO_FORMATTING", + "-DUCONFIG_NO_SERVICE", + "-DUCONFIG_NO_IDNA", + "-DUCONFIG_NO_FILE_IO", + "-DUCONFIG_NO_TRANSLITERATION", + "-DPKGDATA_MODE=static", + "-DICU_DATA_NAME=" + icu_data_name, + ] ) + env_text_server_adv.Append( + CXXFLAGS=[ + "-DICU_DATA_NAME=" + icu_data_name, + ] + ) + + if env_icu.msvc: + env_icu.AppendUnique(CCFLAGS=["/utf-8"]) env_icu.disable_warnings() env_thirdparty = env_icu.Clone() @@ -407,7 +478,9 @@ if env["builtin_icu"]: if not inserted: env.Append(LIBS=[lib]) -env_text_server_adv = env_modules.Clone() +if env_text_server_adv["tools"]: + env_text_server_adv.Append(CXXFLAGS=["-DICU_STATIC_DATA"]) + env_text_server_adv.Append( CPPPATH=[ "#thirdparty/harfbuzz/src", diff --git a/modules/text_server_adv/bitmap_font_adv.cpp b/modules/text_server_adv/bitmap_font_adv.cpp new file mode 100644 index 0000000000..b29bcabbff --- /dev/null +++ b/modules/text_server_adv/bitmap_font_adv.cpp @@ -0,0 +1,575 @@ +/*************************************************************************/ +/* bitmap_font_adv.cpp */ +/*************************************************************************/ +/* This file is part of: */ +/* GODOT ENGINE */ +/* https://godotengine.org */ +/*************************************************************************/ +/* Copyright (c) 2007-2020 Juan Linietsky, Ariel Manzur. */ +/* Copyright (c) 2014-2020 Godot Engine contributors (cf. AUTHORS.md). */ +/* */ +/* Permission is hereby granted, free of charge, to any person obtaining */ +/* a copy of this software and associated documentation files (the */ +/* "Software"), to deal in the Software without restriction, including */ +/* without limitation the rights to use, copy, modify, merge, publish, */ +/* distribute, sublicense, and/or sell copies of the Software, and to */ +/* permit persons to whom the Software is furnished to do so, subject to */ +/* the following conditions: */ +/* */ +/* The above copyright notice and this permission notice shall be */ +/* included in all copies or substantial portions of the Software. */ +/* */ +/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */ +/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */ +/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/ +/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */ +/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */ +/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */ +/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ +/*************************************************************************/ + +#include "bitmap_font_adv.h" + +/*************************************************************************/ +/* hb_bmp_font_t HarfBuzz Bitmap font interface */ +/*************************************************************************/ + +struct hb_bmp_font_t { + BitmapFontDataAdvanced *face = nullptr; + float font_size = 0; + bool unref = false; /* Whether to destroy bm_face when done. */ +}; + +static hb_bmp_font_t *_hb_bmp_font_create(BitmapFontDataAdvanced *p_face, float p_font_size, bool p_unref) { + hb_bmp_font_t *bm_font = reinterpret_cast(calloc(1, sizeof(hb_bmp_font_t))); + + if (!bm_font) { + return nullptr; + } + + bm_font->face = p_face; + bm_font->font_size = p_font_size; + bm_font->unref = p_unref; + + return bm_font; +} + +static void _hb_bmp_font_destroy(void *data) { + hb_bmp_font_t *bm_font = reinterpret_cast(data); + free(bm_font); +} + +static hb_bool_t hb_bmp_get_nominal_glyph(hb_font_t *font, void *font_data, hb_codepoint_t unicode, hb_codepoint_t *glyph, void *user_data) { + const hb_bmp_font_t *bm_font = reinterpret_cast(font_data); + + if (!bm_font->face) { + return false; + } + + if (!bm_font->face->has_char(unicode)) { + if (bm_font->face->has_char(0xF000u + unicode)) { + *glyph = 0xF000u + unicode; + return true; + } else { + return false; + } + } + + *glyph = unicode; + return true; +} + +static hb_position_t hb_bmp_get_glyph_h_advance(hb_font_t *font, void *font_data, hb_codepoint_t glyph, void *user_data) { + const hb_bmp_font_t *bm_font = reinterpret_cast(font_data); + + if (!bm_font->face) { + return 0; + } + + if (!bm_font->face->has_char(glyph)) { + return 0; + } + + return bm_font->face->get_advance(glyph, bm_font->font_size).x * 64; +} + +static hb_position_t hb_bmp_get_glyph_v_advance(hb_font_t *font, void *font_data, hb_codepoint_t glyph, void *user_data) { + const hb_bmp_font_t *bm_font = reinterpret_cast(font_data); + + if (!bm_font->face) { + return 0; + } + + if (!bm_font->face->has_char(glyph)) { + return 0; + } + + return -bm_font->face->get_advance(glyph, bm_font->font_size).y * 64; +} + +static hb_position_t hb_bmp_get_glyph_h_kerning(hb_font_t *font, void *font_data, hb_codepoint_t left_glyph, hb_codepoint_t right_glyph, void *user_data) { + const hb_bmp_font_t *bm_font = reinterpret_cast(font_data); + + if (!bm_font->face) { + return 0; + } + + if (!bm_font->face->has_char(left_glyph)) { + return 0; + } + + if (!bm_font->face->has_char(right_glyph)) { + return 0; + } + + return bm_font->face->get_kerning(left_glyph, right_glyph, bm_font->font_size).x * 64; +} + +static hb_bool_t hb_bmp_get_glyph_v_origin(hb_font_t *font, void *font_data, hb_codepoint_t glyph, hb_position_t *x, hb_position_t *y, void *user_data) { + const hb_bmp_font_t *bm_font = reinterpret_cast(font_data); + + if (!bm_font->face) { + return false; + } + + if (!bm_font->face->has_char(glyph)) { + return false; + } + + *x = bm_font->face->get_advance(glyph, bm_font->font_size).x * 32; + *y = bm_font->face->get_ascent(bm_font->font_size) * 64; + + return true; +} + +static hb_bool_t hb_bmp_get_glyph_extents(hb_font_t *font, void *font_data, hb_codepoint_t glyph, hb_glyph_extents_t *extents, void *user_data) { + const hb_bmp_font_t *bm_font = reinterpret_cast(font_data); + + if (!bm_font->face) { + return false; + } + + if (!bm_font->face->has_char(glyph)) { + return false; + } + + extents->x_bearing = 0; + extents->y_bearing = 0; + extents->width = bm_font->face->get_size(glyph, bm_font->font_size).x * 64; + extents->height = bm_font->face->get_size(glyph, bm_font->font_size).y * 64; + + return true; +} + +static hb_bool_t hb_bmp_get_font_h_extents(hb_font_t *font, void *font_data, hb_font_extents_t *metrics, void *user_data) { + const hb_bmp_font_t *bm_font = reinterpret_cast(font_data); + + if (!bm_font->face) { + return false; + } + + metrics->ascender = bm_font->face->get_ascent(bm_font->font_size); + metrics->descender = bm_font->face->get_descent(bm_font->font_size); + metrics->line_gap = 0; + + return true; +} + +static hb_font_funcs_t *_hb_bmp_get_font_funcs() { + hb_font_funcs_t *funcs = hb_font_funcs_create(); + + hb_font_funcs_set_font_h_extents_func(funcs, hb_bmp_get_font_h_extents, nullptr, nullptr); + //hb_font_funcs_set_font_v_extents_func (funcs, hb_bmp_get_font_v_extents, nullptr, nullptr); + hb_font_funcs_set_nominal_glyph_func(funcs, hb_bmp_get_nominal_glyph, nullptr, nullptr); + //hb_font_funcs_set_variation_glyph_func (funcs, hb_bmp_get_variation_glyph, nullptr, nullptr); + hb_font_funcs_set_glyph_h_advance_func(funcs, hb_bmp_get_glyph_h_advance, nullptr, nullptr); + hb_font_funcs_set_glyph_v_advance_func(funcs, hb_bmp_get_glyph_v_advance, nullptr, nullptr); + //hb_font_funcs_set_glyph_h_origin_func(funcs, hb_bmp_get_glyph_h_origin, nullptr, nullptr); + hb_font_funcs_set_glyph_v_origin_func(funcs, hb_bmp_get_glyph_v_origin, nullptr, nullptr); + hb_font_funcs_set_glyph_h_kerning_func(funcs, hb_bmp_get_glyph_h_kerning, nullptr, nullptr); + //hb_font_funcs_set_glyph_v_kerning_func (funcs, hb_bmp_get_glyph_v_kerning, nullptr, nullptr); + hb_font_funcs_set_glyph_extents_func(funcs, hb_bmp_get_glyph_extents, nullptr, nullptr); + //hb_font_funcs_set_glyph_contour_point_func (funcs, hb_bmp_get_glyph_contour_point, nullptr, nullptr); + //hb_font_funcs_set_glyph_name_func (funcs, hb_bmp_get_glyph_name, nullptr, nullptr); + //hb_font_funcs_set_glyph_from_name_func (funcs, hb_bmp_get_glyph_from_name, nullptr, nullptr); + + hb_font_funcs_make_immutable(funcs); + + return funcs; +} + +static void _hb_bmp_font_set_funcs(hb_font_t *p_font, BitmapFontDataAdvanced *p_face, int p_size, bool p_unref) { + hb_font_set_funcs(p_font, _hb_bmp_get_font_funcs(), _hb_bmp_font_create(p_face, p_size, p_unref), _hb_bmp_font_destroy); +} + +hb_font_t *hb_bmp_font_create(BitmapFontDataAdvanced *p_face, int p_size, hb_destroy_func_t p_destroy) { + hb_font_t *font; + hb_face_t *face = hb_face_create(nullptr, 0); + + font = hb_font_create(face); + hb_face_destroy(face); + _hb_bmp_font_set_funcs(font, p_face, p_size, false); + return font; +} + +/*************************************************************************/ +/* BitmapFontDataAdvanced */ +/*************************************************************************/ + +Error BitmapFontDataAdvanced::load_from_file(const String &p_filename, int p_base_size) { + _THREAD_SAFE_METHOD_ + //fnt format used by angelcode bmfont + //http://www.angelcode.com/products/bmfont/ + + FileAccess *f = FileAccess::open(p_filename, FileAccess::READ); + ERR_FAIL_COND_V_MSG(!f, ERR_FILE_NOT_FOUND, "Can't open font: " + p_filename + "."); + + while (true) { + String line = f->get_line(); + + int delimiter = line.find(" "); + String type = line.substr(0, delimiter); + int pos = delimiter + 1; + Map keys; + + while (pos < line.size() && line[pos] == ' ') { + pos++; + } + + while (pos < line.size()) { + int eq = line.find("=", pos); + if (eq == -1) { + break; + } + String key = line.substr(pos, eq - pos); + int end = -1; + String value; + if (line[eq + 1] == '"') { + end = line.find("\"", eq + 2); + if (end == -1) { + break; + } + value = line.substr(eq + 2, end - 1 - eq - 1); + pos = end + 1; + } else { + end = line.find(" ", eq + 1); + if (end == -1) { + end = line.size(); + } + value = line.substr(eq + 1, end - eq); + pos = end; + } + + while (pos < line.size() && line[pos] == ' ') { + pos++; + } + + keys[key] = value; + } + + if (type == "info") { + if (keys.has("size")) { + base_size = keys["size"].to_int(); + } + } else if (type == "common") { + if (keys.has("lineHeight")) { + height = keys["lineHeight"].to_int(); + } + if (keys.has("base")) { + ascent = keys["base"].to_int(); + } + } else if (type == "page") { + if (keys.has("file")) { + String base_dir = p_filename.get_base_dir(); + String file = base_dir.plus_file(keys["file"]); + if (RenderingServer::get_singleton() != nullptr) { + Ref tex = ResourceLoader::load(file); + if (tex.is_null()) { + ERR_PRINT("Can't load font texture!"); + } else { + ERR_FAIL_COND_V_MSG(tex.is_null(), ERR_FILE_CANT_READ, "It's not a reference to a valid Texture object."); + textures.push_back(tex); + } + } + } + } else if (type == "char") { + Character c; + char32_t idx = 0; + if (keys.has("id")) { + idx = keys["id"].to_int(); + } + if (keys.has("x")) { + c.rect.position.x = keys["x"].to_int(); + } + if (keys.has("y")) { + c.rect.position.y = keys["y"].to_int(); + } + if (keys.has("width")) { + c.rect.size.width = keys["width"].to_int(); + } + if (keys.has("height")) { + c.rect.size.height = keys["height"].to_int(); + } + if (keys.has("xoffset")) { + c.align.x = keys["xoffset"].to_int(); + } + if (keys.has("yoffset")) { + c.align.y = keys["yoffset"].to_int(); + } + if (keys.has("page")) { + c.texture_idx = keys["page"].to_int(); + } + if (keys.has("xadvance")) { + c.advance.x = keys["xadvance"].to_int(); + } + if (keys.has("yadvance")) { + c.advance.x = keys["yadvance"].to_int(); + } + if (c.advance.x < 0) { + c.advance.x = c.rect.size.width + 1; + } + if (c.advance.y < 0) { + c.advance.y = c.rect.size.height + 1; + } + char_map[idx] = c; + } else if (type == "kerning") { + KerningPairKey kpk; + float k = 0; + if (keys.has("first")) { + kpk.A = keys["first"].to_int(); + } + if (keys.has("second")) { + kpk.B = keys["second"].to_int(); + } + if (keys.has("amount")) { + k = keys["amount"].to_int(); + } + kerning_map[kpk] = k; + } + + if (f->eof_reached()) { + break; + } + } + if (base_size == 0) { + base_size = height; + } + + valid = true; + + memdelete(f); + return OK; +} + +Error BitmapFontDataAdvanced::load_from_memory(const uint8_t *p_data, size_t p_size, int p_base_size) { + _THREAD_SAFE_METHOD_ + ERR_FAIL_COND_V(p_data == nullptr, ERR_CANT_CREATE); + ERR_FAIL_COND_V(p_size != sizeof(TextServer::BitmapFontData), ERR_CANT_CREATE); + + const TextServer::BitmapFontData *data = (const TextServer::BitmapFontData *)p_data; + + if (RenderingServer::get_singleton() != nullptr) { + Ref image = memnew(Image(data->img)); + Ref tex = memnew(ImageTexture); + tex->create_from_image(image); + + textures.push_back(tex); + } + + for (int i = 0; i < data->charcount; i++) { + const int *c = &data->char_rects[i * 8]; + + Character chr; + chr.rect.position.x = c[1]; + chr.rect.position.y = c[2]; + chr.rect.size.x = c[3]; + chr.rect.size.y = c[4]; + chr.texture_idx = 0; + if (c[7] < 0) { + chr.advance.x = c[3]; + } else { + chr.advance.x = c[7]; + } + chr.align = Vector2(c[6], c[5]); + char_map[c[0]] = chr; + } + + for (int i = 0; i < data->kerning_count; i++) { + KerningPairKey kpk; + kpk.A = data->kernings[i * 3 + 0]; + kpk.B = data->kernings[i * 3 + 1]; + + if (data->kernings[i * 3 + 2] == 0 && kerning_map.has(kpk)) { + kerning_map.erase(kpk); + } else { + kerning_map[kpk] = data->kernings[i * 3 + 2]; + } + } + + height = data->height; + ascent = data->ascent; + + base_size = p_base_size; + if (base_size == 0) { + base_size = height; + } + + valid = true; + + return OK; +} + +float BitmapFontDataAdvanced::get_height(int p_size) const { + ERR_FAIL_COND_V(!valid, 0.f); + return height * (float(p_size) / float(base_size)); +} + +float BitmapFontDataAdvanced::get_ascent(int p_size) const { + ERR_FAIL_COND_V(!valid, 0.f); + return ascent * (float(p_size) / float(base_size)); +} + +float BitmapFontDataAdvanced::get_descent(int p_size) const { + ERR_FAIL_COND_V(!valid, 0.f); + return (height - ascent) * (float(p_size) / float(base_size)); +} + +float BitmapFontDataAdvanced::get_underline_position(int p_size) const { + ERR_FAIL_COND_V(!valid, 0.f); + return 2 * (float(p_size) / float(base_size)); +} + +float BitmapFontDataAdvanced::get_underline_thickness(int p_size) const { + ERR_FAIL_COND_V(!valid, 0.f); + return 1 * (float(p_size) / float(base_size)); +} + +void BitmapFontDataAdvanced::set_distance_field_hint(bool p_distance_field) { + distance_field_hint = p_distance_field; +} + +bool BitmapFontDataAdvanced::get_distance_field_hint() const { + return distance_field_hint; +} + +float BitmapFontDataAdvanced::get_base_size() const { + return base_size; +} + +hb_font_t *BitmapFontDataAdvanced::get_hb_handle(int p_size) { + _THREAD_SAFE_METHOD_ + ERR_FAIL_COND_V(!valid, nullptr); + if (!cache.has(p_size)) { + cache[p_size] = hb_bmp_font_create(this, p_size, nullptr); + } + return cache[p_size]; +} + +bool BitmapFontDataAdvanced::has_char(char32_t p_char) const { + _THREAD_SAFE_METHOD_ + ERR_FAIL_COND_V(!valid, false); + return char_map.has(p_char); +} + +String BitmapFontDataAdvanced::get_supported_chars() const { + _THREAD_SAFE_METHOD_ + ERR_FAIL_COND_V(!valid, String()); + String chars; + const uint32_t *k = nullptr; + while ((k = char_map.next(k))) { + chars += char32_t(*k); + } + return chars; +} + +Vector2 BitmapFontDataAdvanced::get_advance(uint32_t p_char, int p_size) const { + _THREAD_SAFE_METHOD_ + ERR_FAIL_COND_V(!valid, Vector2()); + const Character *c = char_map.getptr(p_char); + ERR_FAIL_COND_V(c == nullptr, Vector2()); + + return c->advance * (float(p_size) / float(base_size)); +} + +Vector2 BitmapFontDataAdvanced::get_align(uint32_t p_char, int p_size) const { + _THREAD_SAFE_METHOD_ + ERR_FAIL_COND_V(!valid, Vector2()); + const Character *c = char_map.getptr(p_char); + ERR_FAIL_COND_V(c == nullptr, Vector2()); + + return c->align * (float(p_size) / float(base_size)); +} + +Vector2 BitmapFontDataAdvanced::get_size(uint32_t p_char, int p_size) const { + _THREAD_SAFE_METHOD_ + ERR_FAIL_COND_V(!valid, Vector2()); + const Character *c = char_map.getptr(p_char); + ERR_FAIL_COND_V(c == nullptr, Vector2()); + + return c->rect.size * (float(p_size) / float(base_size)); +} + +Vector2 BitmapFontDataAdvanced::get_kerning(uint32_t p_char, uint32_t p_next, int p_size) const { + _THREAD_SAFE_METHOD_ + ERR_FAIL_COND_V(!valid, Vector2()); + KerningPairKey kpk; + kpk.A = p_char; + kpk.B = p_next; + + const Map::Element *E = kerning_map.find(kpk); + if (E) { + return Vector2(-E->get() * (float(p_size) / float(base_size)), 0.f); + } else { + return Vector2(); + } +} + +Vector2 BitmapFontDataAdvanced::draw_glyph(RID p_canvas, int p_size, const Vector2 &p_pos, uint32_t p_index, const Color &p_color) const { + _THREAD_SAFE_METHOD_ + if (p_index == 0) { + return Vector2(); + } + ERR_FAIL_COND_V(!valid, Vector2()); + const Character *c = char_map.getptr(p_index); + + ERR_FAIL_COND_V(c == nullptr, Vector2()); + ERR_FAIL_COND_V(c->texture_idx < -1 || c->texture_idx >= textures.size(), Vector2()); + if (c->texture_idx != -1) { + Point2 cpos = p_pos; + cpos += c->align * (float(p_size) / float(base_size)); + cpos.y -= ascent * (float(p_size) / float(base_size)); + if (RenderingServer::get_singleton() != nullptr) { + if (distance_field_hint) { + RenderingServer::get_singleton()->canvas_item_set_distance_field_mode(p_canvas, true); + } + RenderingServer::get_singleton()->canvas_item_add_texture_rect_region(p_canvas, Rect2(cpos, c->rect.size * (float(p_size) / float(base_size))), textures[c->texture_idx]->get_rid(), c->rect, p_color, false, RID(), RID(), Color(1, 1, 1, 1), false); + if (distance_field_hint) { + RenderingServer::get_singleton()->canvas_item_set_distance_field_mode(p_canvas, false); + } + } + } + + return c->advance * (float(p_size) / float(base_size)); +} + +Vector2 BitmapFontDataAdvanced::draw_glyph_outline(RID p_canvas, int p_size, int p_outline_size, const Vector2 &p_pos, uint32_t p_index, const Color &p_color) const { + _THREAD_SAFE_METHOD_ + if (p_index == 0) { + return Vector2(); + } + ERR_FAIL_COND_V(!valid, Vector2()); + const Character *c = char_map.getptr(p_index); + + ERR_FAIL_COND_V(c == nullptr, Vector2()); + ERR_FAIL_COND_V(c->texture_idx < -1 || c->texture_idx >= textures.size(), Vector2()); + + // Not supported, return advance for compatibility. + + return c->advance * (float(p_size) / float(base_size)); +} + +BitmapFontDataAdvanced::~BitmapFontDataAdvanced() { + for (Map::Element *E = cache.front(); E; E = E->next()) { + hb_font_destroy(E->get()); + } +} diff --git a/modules/text_server_adv/bitmap_font_adv.h b/modules/text_server_adv/bitmap_font_adv.h new file mode 100644 index 0000000000..b2fe7f43af --- /dev/null +++ b/modules/text_server_adv/bitmap_font_adv.h @@ -0,0 +1,115 @@ +/*************************************************************************/ +/* bitmap_font_adv.h */ +/*************************************************************************/ +/* This file is part of: */ +/* GODOT ENGINE */ +/* https://godotengine.org */ +/*************************************************************************/ +/* Copyright (c) 2007-2020 Juan Linietsky, Ariel Manzur. */ +/* Copyright (c) 2014-2020 Godot Engine contributors (cf. AUTHORS.md). */ +/* */ +/* Permission is hereby granted, free of charge, to any person obtaining */ +/* a copy of this software and associated documentation files (the */ +/* "Software"), to deal in the Software without restriction, including */ +/* without limitation the rights to use, copy, modify, merge, publish, */ +/* distribute, sublicense, and/or sell copies of the Software, and to */ +/* permit persons to whom the Software is furnished to do so, subject to */ +/* the following conditions: */ +/* */ +/* The above copyright notice and this permission notice shall be */ +/* included in all copies or substantial portions of the Software. */ +/* */ +/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */ +/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */ +/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/ +/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */ +/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */ +/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */ +/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ +/*************************************************************************/ + +#ifndef BITMAP_FONT_ADV_H +#define BITMAP_FONT_ADV_H + +#include "font_adv.h" + +struct BitmapFontDataAdvanced : public FontDataAdvanced { + _THREAD_SAFE_CLASS_ + +private: + Vector> textures; + + struct Character { + int texture_idx = 0; + Rect2 rect; + Vector2 align; + Vector2 advance = Vector2(-1, -1); + }; + + struct KerningPairKey { + union { + struct { + uint32_t A, B; + }; + + uint64_t pair = 0; + }; + + _FORCE_INLINE_ bool operator<(const KerningPairKey &p_r) const { return pair < p_r.pair; } + }; + + HashMap char_map; + Map kerning_map; + Map cache; + + float height = 0.f; + float ascent = 0.f; + float base_size = 0.f; + bool distance_field_hint = false; + +public: + virtual void clear_cache() override{}; + + virtual Error load_from_file(const String &p_filename, int p_base_size) override; + virtual Error load_from_memory(const uint8_t *p_data, size_t p_size, int p_base_size) override; + + virtual float get_height(int p_size) const override; + virtual float get_ascent(int p_size) const override; + virtual float get_descent(int p_size) const override; + + virtual float get_underline_position(int p_size) const override; + virtual float get_underline_thickness(int p_size) const override; + + virtual void set_antialiased(bool p_antialiased) override{}; + virtual bool get_antialiased() const override { return false; }; + + virtual void set_hinting(TextServer::Hinting p_hinting) override{}; + virtual TextServer::Hinting get_hinting() const override { return TextServer::HINTING_NONE; }; + + virtual void set_distance_field_hint(bool p_distance_field) override; + virtual bool get_distance_field_hint() const override; + + virtual void set_force_autohinter(bool p_enabeld) override{}; + virtual bool get_force_autohinter() const override { return false; }; + + virtual bool has_outline() const override { return false; }; + virtual float get_base_size() const override; + + virtual hb_font_t *get_hb_handle(int p_size) override; + + virtual bool has_char(char32_t p_char) const override; + virtual String get_supported_chars() const override; + + virtual Vector2 get_advance(uint32_t p_char, int p_size) const override; + Vector2 get_align(uint32_t p_char, int p_size) const; + Vector2 get_size(uint32_t p_char, int p_size) const; + virtual Vector2 get_kerning(uint32_t p_char, uint32_t p_next, int p_size) const override; + virtual uint32_t get_glyph_index(char32_t p_char, char32_t p_variation_selector) const override { return (uint32_t)p_char; }; + + virtual Vector2 draw_glyph(RID p_canvas, int p_size, const Vector2 &p_pos, uint32_t p_index, const Color &p_color) const override; + virtual Vector2 draw_glyph_outline(RID p_canvas, int p_size, int p_outline_size, const Vector2 &p_pos, uint32_t p_index, const Color &p_color) const override; + + virtual ~BitmapFontDataAdvanced(); +}; + +#endif // BITMAP_FONT_ADV_H diff --git a/modules/text_server_adv/config.py b/modules/text_server_adv/config.py index 1c8cd12a2d..22482fce24 100644 --- a/modules/text_server_adv/config.py +++ b/modules/text_server_adv/config.py @@ -1,5 +1,6 @@ def can_build(env, platform): - return True + return env.module_check_dependencies("text_server_adv", ["freetype"]) + def configure(env): pass diff --git a/modules/text_server_adv/dynamic_font_adv.cpp b/modules/text_server_adv/dynamic_font_adv.cpp new file mode 100644 index 0000000000..6593da7f2b --- /dev/null +++ b/modules/text_server_adv/dynamic_font_adv.cpp @@ -0,0 +1,973 @@ +/*************************************************************************/ +/* dynamic_font_adv.cpp */ +/*************************************************************************/ +/* This file is part of: */ +/* GODOT ENGINE */ +/* https://godotengine.org */ +/*************************************************************************/ +/* Copyright (c) 2007-2020 Juan Linietsky, Ariel Manzur. */ +/* Copyright (c) 2014-2020 Godot Engine contributors (cf. AUTHORS.md). */ +/* */ +/* Permission is hereby granted, free of charge, to any person obtaining */ +/* a copy of this software and associated documentation files (the */ +/* "Software"), to deal in the Software without restriction, including */ +/* without limitation the rights to use, copy, modify, merge, publish, */ +/* distribute, sublicense, and/or sell copies of the Software, and to */ +/* permit persons to whom the Software is furnished to do so, subject to */ +/* the following conditions: */ +/* */ +/* The above copyright notice and this permission notice shall be */ +/* included in all copies or substantial portions of the Software. */ +/* */ +/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */ +/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */ +/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/ +/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */ +/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */ +/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */ +/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ +/*************************************************************************/ + +#include "dynamic_font_adv.h" + +#include FT_STROKER_H +#include FT_ADVANCES_H + +HashMap> DynamicFontDataAdvanced::font_mem_cache; + +DynamicFontDataAdvanced::DataAtSize *DynamicFontDataAdvanced::get_data_for_size(int p_size, int p_outline_size) { + ERR_FAIL_COND_V(!valid, nullptr); + ERR_FAIL_COND_V(p_size < 0 || p_size > UINT16_MAX, nullptr); + ERR_FAIL_COND_V(p_outline_size < 0 || p_outline_size > UINT16_MAX, nullptr); + + CacheID id; + id.size = p_size; + id.outline_size = p_outline_size; + + DataAtSize *fds = nullptr; + Map::Element *E = nullptr; + if (p_outline_size != 0) { + E = size_cache_outline.find(id); + } else { + E = size_cache.find(id); + } + + if (E != nullptr) { + fds = E->get(); + } else { + // FT_OPEN_STREAM is extremely slow only on Android. + if (OS::get_singleton()->get_name() == "Android" && font_mem == nullptr && font_path != String()) { + if (font_mem_cache.has(font_path)) { + font_mem = font_mem_cache[font_path].ptr(); + font_mem_size = font_mem_cache[font_path].size(); + } else { + FileAccess *f = FileAccess::open(font_path, FileAccess::READ); + if (!f) { + ERR_FAIL_V_MSG(nullptr, "Cannot open font file '" + font_path + "'."); + } + + size_t len = f->get_len(); + font_mem_cache[font_path] = Vector(); + Vector &fontdata = font_mem_cache[font_path]; + fontdata.resize(len); + f->get_buffer(fontdata.ptrw(), len); + font_mem = fontdata.ptr(); + font_mem_size = len; + f->close(); + } + } + + int error = 0; + fds = memnew(DataAtSize); + if (font_mem == nullptr && font_path != String()) { + FileAccess *f = FileAccess::open(font_path, FileAccess::READ); + if (!f) { + memdelete(fds); + ERR_FAIL_V_MSG(nullptr, "Cannot open font file '" + font_path + "'."); + } + + memset(&fds->stream, 0, sizeof(FT_StreamRec)); + fds->stream.base = nullptr; + fds->stream.size = f->get_len(); + fds->stream.pos = 0; + fds->stream.descriptor.pointer = f; + fds->stream.read = _ft_stream_io; + fds->stream.close = _ft_stream_close; + + FT_Open_Args fargs; + memset(&fargs, 0, sizeof(FT_Open_Args)); + fargs.flags = FT_OPEN_STREAM; + fargs.stream = &fds->stream; + error = FT_Open_Face(library, &fargs, 0, &fds->face); + } else if (font_mem) { + memset(&fds->stream, 0, sizeof(FT_StreamRec)); + fds->stream.base = (unsigned char *)font_mem; + fds->stream.size = font_mem_size; + fds->stream.pos = 0; + + FT_Open_Args fargs; + memset(&fargs, 0, sizeof(FT_Open_Args)); + fargs.memory_base = (unsigned char *)font_mem; + fargs.memory_size = font_mem_size; + fargs.flags = FT_OPEN_MEMORY; + fargs.stream = &fds->stream; + error = FT_Open_Face(library, &fargs, 0, &fds->face); + + } else { + memdelete(fds); + ERR_FAIL_V_MSG(nullptr, "DynamicFont uninitialized."); + } + + if (error == FT_Err_Unknown_File_Format) { + memdelete(fds); + ERR_FAIL_V_MSG(nullptr, "Unknown font format."); + } else if (error) { + memdelete(fds); + ERR_FAIL_V_MSG(nullptr, "Error loading font."); + } + + oversampling = TS->font_get_oversampling(); + + if (FT_HAS_COLOR(fds->face) && fds->face->num_fixed_sizes > 0) { + int best_match = 0; + int diff = ABS(p_size - ((int64_t)fds->face->available_sizes[0].width)); + fds->scale_color_font = float(p_size * oversampling) / fds->face->available_sizes[0].width; + for (int i = 1; i < fds->face->num_fixed_sizes; i++) { + int ndiff = ABS(p_size - ((int64_t)fds->face->available_sizes[i].width)); + if (ndiff < diff) { + best_match = i; + diff = ndiff; + fds->scale_color_font = float(p_size * oversampling) / fds->face->available_sizes[i].width; + } + } + FT_Select_Size(fds->face, best_match); + } else { + FT_Set_Pixel_Sizes(fds->face, 0, p_size * oversampling); + } + + fds->size = p_size; + fds->ascent = (fds->face->size->metrics.ascender / 64.0) / oversampling * fds->scale_color_font; + fds->descent = (-fds->face->size->metrics.descender / 64.0) / oversampling * fds->scale_color_font; + fds->underline_position = -fds->face->underline_position / 64.0 / oversampling * fds->scale_color_font; + fds->underline_thickness = fds->face->underline_thickness / 64.0 / oversampling * fds->scale_color_font; + + //Load os2 TTF pable + fds->os2 = (TT_OS2 *)FT_Get_Sfnt_Table(fds->face, FT_SFNT_OS2); + + fds->hb_handle = hb_ft_font_create(fds->face, nullptr); + if (fds->hb_handle == nullptr) { + memdelete(fds); + ERR_FAIL_V_MSG(nullptr, "Error loading HB font."); + } + if (p_outline_size != 0) { + size_cache_outline[id] = fds; + } else { + size_cache[id] = fds; + } + } + + return fds; +} + +unsigned long DynamicFontDataAdvanced::_ft_stream_io(FT_Stream stream, unsigned long offset, unsigned char *buffer, unsigned long count) { + FileAccess *f = (FileAccess *)stream->descriptor.pointer; + + if (f->get_position() != offset) { + f->seek(offset); + } + if (count == 0) { + return 0; + } + + return f->get_buffer(buffer, count); +} + +void DynamicFontDataAdvanced::_ft_stream_close(FT_Stream stream) { + FileAccess *f = (FileAccess *)stream->descriptor.pointer; + f->close(); + memdelete(f); +} + +Dictionary DynamicFontDataAdvanced::get_feature_list() const { + _THREAD_SAFE_METHOD_ + DataAtSize *fds = const_cast(this)->get_data_for_size(base_size); + if (fds == nullptr) { + return Dictionary(); + } + + Dictionary out; + // Read feature flags. + unsigned int count = hb_ot_layout_table_get_feature_tags(hb_font_get_face(fds->hb_handle), HB_OT_TAG_GSUB, 0, NULL, NULL); + if (count != 0) { + hb_tag_t *feature_tags = (hb_tag_t *)memalloc(count * sizeof(hb_tag_t)); + hb_ot_layout_table_get_feature_tags(hb_font_get_face(fds->hb_handle), HB_OT_TAG_GSUB, 0, &count, feature_tags); + for (unsigned int i = 0; i < count; i++) { + out[feature_tags[i]] = 1; + } + memfree(feature_tags); + } + count = hb_ot_layout_table_get_feature_tags(hb_font_get_face(fds->hb_handle), HB_OT_TAG_GPOS, 0, NULL, NULL); + if (count != 0) { + hb_tag_t *feature_tags = (hb_tag_t *)memalloc(count * sizeof(hb_tag_t)); + hb_ot_layout_table_get_feature_tags(hb_font_get_face(fds->hb_handle), HB_OT_TAG_GPOS, 0, &count, feature_tags); + for (unsigned int i = 0; i < count; i++) { + out[feature_tags[i]] = 1; + } + memfree(feature_tags); + } + + return out; +} + +DynamicFontDataAdvanced::TexturePosition DynamicFontDataAdvanced::find_texture_pos_for_glyph(DynamicFontDataAdvanced::DataAtSize *p_data, int p_color_size, Image::Format p_image_format, int p_width, int p_height) { + TexturePosition ret; + ret.index = -1; + ret.x = 0; + ret.y = 0; + + int mw = p_width; + int mh = p_height; + + for (int i = 0; i < p_data->textures.size(); i++) { + const CharTexture &ct = p_data->textures[i]; + + if (RenderingServer::get_singleton() != nullptr) { + if (ct.texture->get_format() != p_image_format) { + continue; + } + } + + if (mw > ct.texture_size || mh > ct.texture_size) { //too big for this texture + continue; + } + + ret.y = 0x7FFFFFFF; + ret.x = 0; + + for (int j = 0; j < ct.texture_size - mw; j++) { + int max_y = 0; + + for (int k = j; k < j + mw; k++) { + int y = ct.offsets[k]; + if (y > max_y) { + max_y = y; + } + } + + if (max_y < ret.y) { + ret.y = max_y; + ret.x = j; + } + } + + if (ret.y == 0x7FFFFFFF || ret.y + mh > ct.texture_size) { + continue; //fail, could not fit it here + } + + ret.index = i; + break; + } + + if (ret.index == -1) { + //could not find texture to fit, create one + ret.x = 0; + ret.y = 0; + + int texsize = MAX(p_data->size * oversampling * 8, 256); + if (mw > texsize) { + texsize = mw; //special case, adapt to it? + } + if (mh > texsize) { + texsize = mh; //special case, adapt to it? + } + + texsize = next_power_of_2(texsize); + + texsize = MIN(texsize, 4096); + + CharTexture tex; + tex.texture_size = texsize; + tex.imgdata.resize(texsize * texsize * p_color_size); //grayscale alpha + + { + //zero texture + uint8_t *w = tex.imgdata.ptrw(); + ERR_FAIL_COND_V(texsize * texsize * p_color_size > tex.imgdata.size(), ret); + // Initialize the texture to all-white pixels to prevent artifacts when the + // font is displayed at a non-default scale with filtering enabled. + if (p_color_size == 2) { + for (int i = 0; i < texsize * texsize * p_color_size; i += 2) { // FORMAT_LA8 + w[i + 0] = 255; + w[i + 1] = 0; + } + } else if (p_color_size == 4) { + for (int i = 0; i < texsize * texsize * p_color_size; i += 4) { // FORMAT_RGBA8 + w[i + 0] = 255; + w[i + 1] = 255; + w[i + 2] = 255; + w[i + 3] = 0; + } + } else { + ERR_FAIL_V(ret); + } + } + tex.offsets.resize(texsize); + for (int i = 0; i < texsize; i++) { //zero offsets + tex.offsets.write[i] = 0; + } + + p_data->textures.push_back(tex); + ret.index = p_data->textures.size() - 1; + } + + return ret; +} + +DynamicFontDataAdvanced::Character DynamicFontDataAdvanced::Character::not_found() { + Character ch; + return ch; +} + +DynamicFontDataAdvanced::Character DynamicFontDataAdvanced::bitmap_to_character(DynamicFontDataAdvanced::DataAtSize *p_data, FT_Bitmap bitmap, int yofs, int xofs, const Vector2 &advance) { + int w = bitmap.width; + int h = bitmap.rows; + + int mw = w + rect_margin * 2; + int mh = h + rect_margin * 2; + + ERR_FAIL_COND_V(mw > 4096, Character::not_found()); + ERR_FAIL_COND_V(mh > 4096, Character::not_found()); + + int color_size = bitmap.pixel_mode == FT_PIXEL_MODE_BGRA ? 4 : 2; + Image::Format require_format = color_size == 4 ? Image::FORMAT_RGBA8 : Image::FORMAT_LA8; + + TexturePosition tex_pos = find_texture_pos_for_glyph(p_data, color_size, require_format, mw, mh); + ERR_FAIL_COND_V(tex_pos.index < 0, Character::not_found()); + + //fit character in char texture + + CharTexture &tex = p_data->textures.write[tex_pos.index]; + + { + uint8_t *wr = tex.imgdata.ptrw(); + + for (int i = 0; i < h; i++) { + for (int j = 0; j < w; j++) { + int ofs = ((i + tex_pos.y + rect_margin) * tex.texture_size + j + tex_pos.x + rect_margin) * color_size; + ERR_FAIL_COND_V(ofs >= tex.imgdata.size(), Character::not_found()); + switch (bitmap.pixel_mode) { + case FT_PIXEL_MODE_MONO: { + int byte = i * bitmap.pitch + (j >> 3); + int bit = 1 << (7 - (j % 8)); + wr[ofs + 0] = 255; //grayscale as 1 + wr[ofs + 1] = (bitmap.buffer[byte] & bit) ? 255 : 0; + } break; + case FT_PIXEL_MODE_GRAY: + wr[ofs + 0] = 255; //grayscale as 1 + wr[ofs + 1] = bitmap.buffer[i * bitmap.pitch + j]; + break; + case FT_PIXEL_MODE_BGRA: { + int ofs_color = i * bitmap.pitch + (j << 2); + wr[ofs + 2] = bitmap.buffer[ofs_color + 0]; + wr[ofs + 1] = bitmap.buffer[ofs_color + 1]; + wr[ofs + 0] = bitmap.buffer[ofs_color + 2]; + wr[ofs + 3] = bitmap.buffer[ofs_color + 3]; + } break; + // TODO: FT_PIXEL_MODE_LCD + default: + ERR_FAIL_V_MSG(Character::not_found(), "Font uses unsupported pixel format: " + itos(bitmap.pixel_mode) + "."); + break; + } + } + } + } + + //blit to image and texture + { + if (RenderingServer::get_singleton() != nullptr) { + Ref img = memnew(Image(tex.texture_size, tex.texture_size, 0, require_format, tex.imgdata)); + + if (tex.texture.is_null()) { + tex.texture.instance(); + tex.texture->create_from_image(img); + } else { + tex.texture->update(img); //update + } + } + } + + // update height array + for (int k = tex_pos.x; k < tex_pos.x + mw; k++) { + tex.offsets.write[k] = tex_pos.y + mh; + } + + Character chr; + chr.align = Vector2(xofs, -yofs) * p_data->scale_color_font / oversampling; + chr.advance = advance * p_data->scale_color_font / oversampling; + chr.texture_idx = tex_pos.index; + chr.found = true; + + chr.rect_uv = Rect2(tex_pos.x + rect_margin, tex_pos.y + rect_margin, w, h); + chr.rect = chr.rect_uv; + chr.rect.position /= oversampling; + chr.rect.size *= (p_data->scale_color_font / oversampling); + return chr; +} + +void DynamicFontDataAdvanced::update_glyph(int p_size, uint32_t p_index) { + DataAtSize *fds = get_data_for_size(p_size, false); + ERR_FAIL_COND(fds == nullptr); + + if (fds->glyph_map.has(p_index)) { + return; + } + + Character character = Character::not_found(); + FT_GlyphSlot slot = fds->face->glyph; + + if (p_index == 0) { + fds->glyph_map[p_index] = character; + return; + } + + int ft_hinting; + switch (hinting) { + case TextServer::HINTING_NONE: + ft_hinting = FT_LOAD_NO_HINTING; + break; + case TextServer::HINTING_LIGHT: + ft_hinting = FT_LOAD_TARGET_LIGHT; + break; + default: + ft_hinting = FT_LOAD_TARGET_NORMAL; + break; + } + + FT_Fixed v, h; + FT_Get_Advance(fds->face, p_index, FT_HAS_COLOR(fds->face) ? FT_LOAD_COLOR : FT_LOAD_DEFAULT | (force_autohinter ? FT_LOAD_FORCE_AUTOHINT : 0) | ft_hinting, &h); + FT_Get_Advance(fds->face, p_index, FT_HAS_COLOR(fds->face) ? FT_LOAD_COLOR : FT_LOAD_DEFAULT | (force_autohinter ? FT_LOAD_FORCE_AUTOHINT : 0) | ft_hinting | FT_LOAD_VERTICAL_LAYOUT, &v); + + int error = FT_Load_Glyph(fds->face, p_index, FT_HAS_COLOR(fds->face) ? FT_LOAD_COLOR : FT_LOAD_DEFAULT | (force_autohinter ? FT_LOAD_FORCE_AUTOHINT : 0) | ft_hinting); + if (error) { + fds->glyph_map[p_index] = character; + return; + } + + error = FT_Render_Glyph(fds->face->glyph, antialiased ? FT_RENDER_MODE_NORMAL : FT_RENDER_MODE_MONO); + if (!error) { + character = bitmap_to_character(fds, slot->bitmap, slot->bitmap_top, slot->bitmap_left, Vector2((h + (1 << 9)) >> 10, (v + (1 << 9)) >> 10) / 64.0); + } + + fds->glyph_map[p_index] = character; +} + +void DynamicFontDataAdvanced::update_glyph_outline(int p_size, int p_outline_size, uint32_t p_index) { + DataAtSize *fds = get_data_for_size(p_size, p_outline_size); + ERR_FAIL_COND(fds == nullptr); + + if (fds->glyph_map.has(p_index)) { + return; + } + + Character character = Character::not_found(); + if (p_index == 0) { + fds->glyph_map[p_index] = character; + return; + } + + int error = FT_Load_Glyph(fds->face, p_index, FT_LOAD_NO_BITMAP | (force_autohinter ? FT_LOAD_FORCE_AUTOHINT : 0)); + if (error) { + fds->glyph_map[p_index] = character; + return; + } + + FT_Stroker stroker; + if (FT_Stroker_New(library, &stroker) != 0) { + fds->glyph_map[p_index] = character; + return; + } + + FT_Stroker_Set(stroker, (int)(p_outline_size * oversampling * 64.0), FT_STROKER_LINECAP_BUTT, FT_STROKER_LINEJOIN_ROUND, 0); + FT_Glyph glyph; + FT_BitmapGlyph glyph_bitmap; + + if (FT_Get_Glyph(fds->face->glyph, &glyph) != 0) { + goto cleanup_stroker; + } + if (FT_Glyph_Stroke(&glyph, stroker, 1) != 0) { + goto cleanup_glyph; + } + if (FT_Glyph_To_Bitmap(&glyph, antialiased ? FT_RENDER_MODE_NORMAL : FT_RENDER_MODE_MONO, nullptr, 1) != 0) { + goto cleanup_glyph; + } + + glyph_bitmap = (FT_BitmapGlyph)glyph; + character = bitmap_to_character(fds, glyph_bitmap->bitmap, glyph_bitmap->top, glyph_bitmap->left, Vector2()); + +cleanup_glyph: + FT_Done_Glyph(glyph); +cleanup_stroker: + FT_Stroker_Done(stroker); + + fds->glyph_map[p_index] = character; +} + +void DynamicFontDataAdvanced::clear_cache() { + _THREAD_SAFE_METHOD_ + for (Map::Element *E = size_cache.front(); E; E = E->next()) { + memdelete(E->get()); + } + size_cache.clear(); + for (Map::Element *E = size_cache_outline.front(); E; E = E->next()) { + memdelete(E->get()); + } + size_cache_outline.clear(); +} + +Error DynamicFontDataAdvanced::load_from_file(const String &p_filename, int p_base_size) { + _THREAD_SAFE_METHOD_ + if (library == nullptr) { + int error = FT_Init_FreeType(&library); + ERR_FAIL_COND_V_MSG(error != 0, ERR_CANT_CREATE, "Error initializing FreeType."); + } + clear_cache(); + + font_path = p_filename; + base_size = p_base_size; + + valid = true; + DataAtSize *fds = get_data_for_size(base_size); // load base size. + if (fds == nullptr) { + valid = false; + ERR_FAIL_V(ERR_CANT_CREATE); + } + + return OK; +} + +Error DynamicFontDataAdvanced::load_from_memory(const uint8_t *p_data, size_t p_size, int p_base_size) { + _THREAD_SAFE_METHOD_ + if (library == nullptr) { + int error = FT_Init_FreeType(&library); + ERR_FAIL_COND_V_MSG(error != 0, ERR_CANT_CREATE, "Error initializing FreeType."); + } + clear_cache(); + + font_mem = p_data; + font_mem_size = p_size; + base_size = p_base_size; + + valid = true; + DataAtSize *fds = get_data_for_size(base_size); // load base size. + if (fds == nullptr) { + valid = false; + ERR_FAIL_V(ERR_CANT_CREATE); + } + + return OK; +} + +float DynamicFontDataAdvanced::get_height(int p_size) const { + _THREAD_SAFE_METHOD_ + DataAtSize *fds = const_cast(this)->get_data_for_size(p_size); + ERR_FAIL_COND_V(fds == nullptr, 0.f); + return fds->ascent + fds->descent; +} + +float DynamicFontDataAdvanced::get_ascent(int p_size) const { + _THREAD_SAFE_METHOD_ + DataAtSize *fds = const_cast(this)->get_data_for_size(p_size); + ERR_FAIL_COND_V(fds == nullptr, 0.f); + return fds->ascent; +} + +float DynamicFontDataAdvanced::get_descent(int p_size) const { + _THREAD_SAFE_METHOD_ + DataAtSize *fds = const_cast(this)->get_data_for_size(p_size); + ERR_FAIL_COND_V(fds == nullptr, 0.f); + return fds->descent; +} + +float DynamicFontDataAdvanced::get_underline_position(int p_size) const { + _THREAD_SAFE_METHOD_ + DataAtSize *fds = const_cast(this)->get_data_for_size(p_size); + ERR_FAIL_COND_V(fds == nullptr, 0.f); + return fds->underline_position; +} + +float DynamicFontDataAdvanced::get_underline_thickness(int p_size) const { + _THREAD_SAFE_METHOD_ + DataAtSize *fds = const_cast(this)->get_data_for_size(p_size); + ERR_FAIL_COND_V(fds == nullptr, 0.f); + return fds->underline_thickness; +} + +bool DynamicFontDataAdvanced::is_script_supported(uint32_t p_script) const { + _THREAD_SAFE_METHOD_ + DataAtSize *fds = const_cast(this)->get_data_for_size(base_size); + ERR_FAIL_COND_V(fds == nullptr, false); + + unsigned int count = hb_ot_layout_table_get_script_tags(hb_font_get_face(fds->hb_handle), HB_OT_TAG_GSUB, 0, NULL, NULL); + if (count != 0) { + hb_tag_t *script_tags = (hb_tag_t *)memalloc(count * sizeof(hb_tag_t)); + hb_ot_layout_table_get_script_tags(hb_font_get_face(fds->hb_handle), HB_OT_TAG_GSUB, 0, &count, script_tags); + for (unsigned int i = 0; i < count; i++) { + if (p_script == script_tags[i]) { + memfree(script_tags); + return true; + } + } + memfree(script_tags); + } + count = hb_ot_layout_table_get_script_tags(hb_font_get_face(fds->hb_handle), HB_OT_TAG_GPOS, 0, NULL, NULL); + if (count != 0) { + hb_tag_t *script_tags = (hb_tag_t *)memalloc(count * sizeof(hb_tag_t)); + hb_ot_layout_table_get_script_tags(hb_font_get_face(fds->hb_handle), HB_OT_TAG_GPOS, 0, &count, script_tags); + for (unsigned int i = 0; i < count; i++) { + if (p_script == script_tags[i]) { + memfree(script_tags); + return true; + } + } + memfree(script_tags); + } + + if (!fds->os2) { + return false; + } + + switch (p_script) { + case HB_SCRIPT_COMMON: + return (fds->os2->ulUnicodeRange1 & 1L << 4) || (fds->os2->ulUnicodeRange1 & 1L << 5) || (fds->os2->ulUnicodeRange1 & 1L << 6) || (fds->os2->ulUnicodeRange1 & 1L << 31) || (fds->os2->ulUnicodeRange2 & 1L << 0) || (fds->os2->ulUnicodeRange2 & 1L << 1) || (fds->os2->ulUnicodeRange2 & 1L << 2) || (fds->os2->ulUnicodeRange2 & 1L << 3) || (fds->os2->ulUnicodeRange2 & 1L << 4) || (fds->os2->ulUnicodeRange2 & 1L << 5) || (fds->os2->ulUnicodeRange2 & 1L << 6) || (fds->os2->ulUnicodeRange2 & 1L << 7) || (fds->os2->ulUnicodeRange2 & 1L << 8) || (fds->os2->ulUnicodeRange2 & 1L << 9) || (fds->os2->ulUnicodeRange2 & 1L << 10) || (fds->os2->ulUnicodeRange2 & 1L << 11) || (fds->os2->ulUnicodeRange2 & 1L << 12) || (fds->os2->ulUnicodeRange2 & 1L << 13) || (fds->os2->ulUnicodeRange2 & 1L << 14) || (fds->os2->ulUnicodeRange2 & 1L << 15) || (fds->os2->ulUnicodeRange2 & 1L << 30) || (fds->os2->ulUnicodeRange3 & 1L << 0) || (fds->os2->ulUnicodeRange3 & 1L << 1) || (fds->os2->ulUnicodeRange3 & 1L << 2) || (fds->os2->ulUnicodeRange3 & 1L << 4) || (fds->os2->ulUnicodeRange3 & 1L << 5) || (fds->os2->ulUnicodeRange3 & 1L << 18) || (fds->os2->ulUnicodeRange3 & 1L << 24) || (fds->os2->ulUnicodeRange3 & 1L << 25) || (fds->os2->ulUnicodeRange3 & 1L << 26) || (fds->os2->ulUnicodeRange3 & 1L << 27) || (fds->os2->ulUnicodeRange3 & 1L << 28) || (fds->os2->ulUnicodeRange4 & 1L << 3) || (fds->os2->ulUnicodeRange4 & 1L << 6) || (fds->os2->ulUnicodeRange4 & 1L << 15) || (fds->os2->ulUnicodeRange4 & 1L << 23) || (fds->os2->ulUnicodeRange4 & 1L << 24) || (fds->os2->ulUnicodeRange4 & 1L << 26); + case HB_SCRIPT_LATIN: + return (fds->os2->ulUnicodeRange1 & 1L << 0) || (fds->os2->ulUnicodeRange1 & 1L << 1) || (fds->os2->ulUnicodeRange1 & 1L << 2) || (fds->os2->ulUnicodeRange1 & 1L << 3) || (fds->os2->ulUnicodeRange1 & 1L << 29); + case HB_SCRIPT_GREEK: + return (fds->os2->ulUnicodeRange1 & 1L << 7) || (fds->os2->ulUnicodeRange1 & 1L << 30); + case HB_SCRIPT_COPTIC: + return (fds->os2->ulUnicodeRange1 & 1L << 8); + case HB_SCRIPT_CYRILLIC: + return (fds->os2->ulUnicodeRange1 & 1L << 9); + case HB_SCRIPT_ARMENIAN: + return (fds->os2->ulUnicodeRange1 & 1L << 10); + case HB_SCRIPT_HEBREW: + return (fds->os2->ulUnicodeRange1 & 1L << 11); + case HB_SCRIPT_VAI: + return (fds->os2->ulUnicodeRange1 & 1L << 12); + case HB_SCRIPT_ARABIC: + return (fds->os2->ulUnicodeRange1 & 1L << 13) || (fds->os2->ulUnicodeRange2 & 1L << 31) || (fds->os2->ulUnicodeRange3 & 1L << 3); + case HB_SCRIPT_NKO: + return (fds->os2->ulUnicodeRange1 & 1L << 14); + case HB_SCRIPT_DEVANAGARI: + return (fds->os2->ulUnicodeRange1 & 1L << 15); + case HB_SCRIPT_BENGALI: + return (fds->os2->ulUnicodeRange1 & 1L << 16); + case HB_SCRIPT_GURMUKHI: + return (fds->os2->ulUnicodeRange1 & 1L << 17); + case HB_SCRIPT_GUJARATI: + return (fds->os2->ulUnicodeRange1 & 1L << 18); + case HB_SCRIPT_ORIYA: + return (fds->os2->ulUnicodeRange1 & 1L << 19); + case HB_SCRIPT_TAMIL: + return (fds->os2->ulUnicodeRange1 & 1L << 20); + case HB_SCRIPT_TELUGU: + return (fds->os2->ulUnicodeRange1 & 1L << 21); + case HB_SCRIPT_KANNADA: + return (fds->os2->ulUnicodeRange1 & 1L << 22); + case HB_SCRIPT_MALAYALAM: + return (fds->os2->ulUnicodeRange1 & 1L << 23); + case HB_SCRIPT_THAI: + return (fds->os2->ulUnicodeRange1 & 1L << 24); + case HB_SCRIPT_LAO: + return (fds->os2->ulUnicodeRange1 & 1L << 25); + case HB_SCRIPT_GEORGIAN: + return (fds->os2->ulUnicodeRange1 & 1L << 26); + case HB_SCRIPT_BALINESE: + return (fds->os2->ulUnicodeRange1 & 1L << 27); + case HB_SCRIPT_HANGUL: + return (fds->os2->ulUnicodeRange1 & 1L << 28) || (fds->os2->ulUnicodeRange2 & 1L << 20) || (fds->os2->ulUnicodeRange2 & 1L << 24); + case HB_SCRIPT_HAN: + return (fds->os2->ulUnicodeRange2 & 1L << 21) || (fds->os2->ulUnicodeRange2 & 1L << 22) || (fds->os2->ulUnicodeRange2 & 1L << 23) || (fds->os2->ulUnicodeRange2 & 1L << 26) || (fds->os2->ulUnicodeRange2 & 1L << 27) || (fds->os2->ulUnicodeRange2 & 1L << 29); + case HB_SCRIPT_HIRAGANA: + return (fds->os2->ulUnicodeRange2 & 1L << 17); + case HB_SCRIPT_KATAKANA: + return (fds->os2->ulUnicodeRange2 & 1L << 18); + case HB_SCRIPT_BOPOMOFO: + return (fds->os2->ulUnicodeRange2 & 1L << 19); + case HB_SCRIPT_TIBETAN: + return (fds->os2->ulUnicodeRange3 & 1L << 6); + case HB_SCRIPT_SYRIAC: + return (fds->os2->ulUnicodeRange3 & 1L << 7); + case HB_SCRIPT_THAANA: + return (fds->os2->ulUnicodeRange3 & 1L << 8); + case HB_SCRIPT_SINHALA: + return (fds->os2->ulUnicodeRange3 & 1L << 9); + case HB_SCRIPT_MYANMAR: + return (fds->os2->ulUnicodeRange3 & 1L << 10); + case HB_SCRIPT_ETHIOPIC: + return (fds->os2->ulUnicodeRange3 & 1L << 11); + case HB_SCRIPT_CHEROKEE: + return (fds->os2->ulUnicodeRange3 & 1L << 12); + case HB_SCRIPT_CANADIAN_SYLLABICS: + return (fds->os2->ulUnicodeRange3 & 1L << 13); + case HB_SCRIPT_OGHAM: + return (fds->os2->ulUnicodeRange3 & 1L << 14); + case HB_SCRIPT_RUNIC: + return (fds->os2->ulUnicodeRange3 & 1L << 15); + case HB_SCRIPT_KHMER: + return (fds->os2->ulUnicodeRange3 & 1L << 16); + case HB_SCRIPT_MONGOLIAN: + return (fds->os2->ulUnicodeRange3 & 1L << 17); + case HB_SCRIPT_YI: + return (fds->os2->ulUnicodeRange3 & 1L << 19); + case HB_SCRIPT_HANUNOO: + case HB_SCRIPT_TAGBANWA: + case HB_SCRIPT_BUHID: + case HB_SCRIPT_TAGALOG: + return (fds->os2->ulUnicodeRange3 & 1L << 20); + case HB_SCRIPT_OLD_ITALIC: + return (fds->os2->ulUnicodeRange3 & 1L << 21); + case HB_SCRIPT_GOTHIC: + return (fds->os2->ulUnicodeRange3 & 1L << 22); + case HB_SCRIPT_DESERET: + return (fds->os2->ulUnicodeRange3 & 1L << 23); + case HB_SCRIPT_LIMBU: + return (fds->os2->ulUnicodeRange3 & 1L << 29); + case HB_SCRIPT_TAI_LE: + return (fds->os2->ulUnicodeRange3 & 1L << 30); + case HB_SCRIPT_NEW_TAI_LUE: + return (fds->os2->ulUnicodeRange3 & 1L << 31); + case HB_SCRIPT_BUGINESE: + return (fds->os2->ulUnicodeRange4 & 1L << 0); + case HB_SCRIPT_GLAGOLITIC: + return (fds->os2->ulUnicodeRange4 & 1L << 1); + case HB_SCRIPT_TIFINAGH: + return (fds->os2->ulUnicodeRange4 & 1L << 2); + case HB_SCRIPT_SYLOTI_NAGRI: + return (fds->os2->ulUnicodeRange4 & 1L << 4); + case HB_SCRIPT_LINEAR_B: + return (fds->os2->ulUnicodeRange4 & 1L << 5); + case HB_SCRIPT_UGARITIC: + return (fds->os2->ulUnicodeRange4 & 1L << 7); + case HB_SCRIPT_OLD_PERSIAN: + return (fds->os2->ulUnicodeRange4 & 1L << 8); + case HB_SCRIPT_SHAVIAN: + return (fds->os2->ulUnicodeRange4 & 1L << 9); + case HB_SCRIPT_OSMANYA: + return (fds->os2->ulUnicodeRange4 & 1L << 10); + case HB_SCRIPT_CYPRIOT: + return (fds->os2->ulUnicodeRange4 & 1L << 11); + case HB_SCRIPT_KHAROSHTHI: + return (fds->os2->ulUnicodeRange4 & 1L << 12); + case HB_SCRIPT_TAI_VIET: + return (fds->os2->ulUnicodeRange4 & 1L << 13); + case HB_SCRIPT_CUNEIFORM: + return (fds->os2->ulUnicodeRange4 & 1L << 14); + case HB_SCRIPT_SUNDANESE: + return (fds->os2->ulUnicodeRange4 & 1L << 16); + case HB_SCRIPT_LEPCHA: + return (fds->os2->ulUnicodeRange4 & 1L << 17); + case HB_SCRIPT_OL_CHIKI: + return (fds->os2->ulUnicodeRange4 & 1L << 18); + case HB_SCRIPT_SAURASHTRA: + return (fds->os2->ulUnicodeRange4 & 1L << 19); + case HB_SCRIPT_KAYAH_LI: + return (fds->os2->ulUnicodeRange4 & 1L << 20); + case HB_SCRIPT_REJANG: + return (fds->os2->ulUnicodeRange4 & 1L << 21); + case HB_SCRIPT_CHAM: + return (fds->os2->ulUnicodeRange4 & 1L << 22); + case HB_SCRIPT_ANATOLIAN_HIEROGLYPHS: + return (fds->os2->ulUnicodeRange4 & 1L << 25); + default: + return false; + }; +} + +void DynamicFontDataAdvanced::set_antialiased(bool p_antialiased) { + if (antialiased != p_antialiased) { + clear_cache(); + antialiased = p_antialiased; + } +} + +bool DynamicFontDataAdvanced::get_antialiased() const { + return antialiased; +} + +void DynamicFontDataAdvanced::set_force_autohinter(bool p_enabled) { + if (force_autohinter != p_enabled) { + clear_cache(); + force_autohinter = p_enabled; + } +} + +bool DynamicFontDataAdvanced::get_force_autohinter() const { + return force_autohinter; +} + +void DynamicFontDataAdvanced::set_hinting(TextServer::Hinting p_hinting) { + if (hinting != p_hinting) { + clear_cache(); + hinting = p_hinting; + } +} + +TextServer::Hinting DynamicFontDataAdvanced::get_hinting() const { + return hinting; +} + +bool DynamicFontDataAdvanced::has_outline() const { + return true; +} + +float DynamicFontDataAdvanced::get_base_size() const { + return base_size; +} + +String DynamicFontDataAdvanced::get_supported_chars() const { + _THREAD_SAFE_METHOD_ + DataAtSize *fds = const_cast(this)->get_data_for_size(base_size); + ERR_FAIL_COND_V(fds == nullptr, String()); + + String chars; + + FT_UInt gindex; + FT_ULong charcode = FT_Get_First_Char(fds->face, &gindex); + while (gindex != 0) { + if (charcode != 0) { + chars += char32_t(charcode); + } + charcode = FT_Get_Next_Char(fds->face, charcode, &gindex); + } + + return chars; +} + +float DynamicFontDataAdvanced::get_font_scale(int p_size) const { + _THREAD_SAFE_METHOD_ + DataAtSize *fds = const_cast(this)->get_data_for_size(p_size); + ERR_FAIL_COND_V(fds == nullptr, 1.0f); + + return fds->scale_color_font / oversampling; +} + +bool DynamicFontDataAdvanced::has_char(char32_t p_char) const { + _THREAD_SAFE_METHOD_ + DataAtSize *fds = const_cast(this)->get_data_for_size(base_size); + ERR_FAIL_COND_V(fds == nullptr, false); + + const_cast(this)->update_glyph(base_size, FT_Get_Char_Index(fds->face, p_char)); + Character ch = fds->glyph_map[FT_Get_Char_Index(fds->face, p_char)]; + + return (ch.found); +} + +hb_font_t *DynamicFontDataAdvanced::get_hb_handle(int p_size) { + _THREAD_SAFE_METHOD_ + DataAtSize *fds = get_data_for_size(p_size); + ERR_FAIL_COND_V(fds == nullptr, nullptr); + + return fds->hb_handle; +} + +uint32_t DynamicFontDataAdvanced::get_glyph_index(char32_t p_char, char32_t p_variation_selector) const { + _THREAD_SAFE_METHOD_ + DataAtSize *fds = const_cast(this)->get_data_for_size(base_size); + ERR_FAIL_COND_V(fds == nullptr, 0); + + if (p_variation_selector == 0x0000) { + return FT_Get_Char_Index(fds->face, p_char); + } else { + return FT_Face_GetCharVariantIndex(fds->face, p_char, p_variation_selector); + } +} + +Vector2 DynamicFontDataAdvanced::get_advance(uint32_t p_index, int p_size) const { + _THREAD_SAFE_METHOD_ + DataAtSize *fds = const_cast(this)->get_data_for_size(p_size); + ERR_FAIL_COND_V(fds == nullptr, Vector2()); + + const_cast(this)->update_glyph(p_size, p_index); + Character ch = fds->glyph_map[p_index]; + + return ch.advance; +} + +Vector2 DynamicFontDataAdvanced::get_kerning(uint32_t p_char, uint32_t p_next, int p_size) const { + _THREAD_SAFE_METHOD_ + DataAtSize *fds = const_cast(this)->get_data_for_size(p_size); + ERR_FAIL_COND_V(fds == nullptr, Vector2()); + + FT_Vector delta; + FT_Get_Kerning(fds->face, p_char, p_next, FT_KERNING_DEFAULT, &delta); + return Vector2(delta.x, delta.y); +} + +Vector2 DynamicFontDataAdvanced::draw_glyph(RID p_canvas, int p_size, const Vector2 &p_pos, uint32_t p_index, const Color &p_color) const { + _THREAD_SAFE_METHOD_ + DataAtSize *fds = const_cast(this)->get_data_for_size(p_size); + ERR_FAIL_COND_V(fds == nullptr, Vector2()); + + const_cast(this)->update_glyph(p_size, p_index); + Character ch = fds->glyph_map[p_index]; + + Vector2 advance; + if (ch.found) { + ERR_FAIL_COND_V(ch.texture_idx < -1 || ch.texture_idx >= fds->textures.size(), Vector2()); + + if (ch.texture_idx != -1) { + Point2 cpos = p_pos; + cpos += ch.align; + Color modulate = p_color; + if (FT_HAS_COLOR(fds->face)) { + modulate.r = modulate.g = modulate.b = 1.0; + } + if (RenderingServer::get_singleton() != nullptr) { + RID texture = fds->textures[ch.texture_idx].texture->get_rid(); + RenderingServer::get_singleton()->canvas_item_add_texture_rect_region(p_canvas, Rect2(cpos, ch.rect.size), texture, ch.rect_uv, modulate, false, RID(), RID(), Color(1, 1, 1, 1), false); + } + } + + advance = ch.advance; + } + + return advance; +} + +Vector2 DynamicFontDataAdvanced::draw_glyph_outline(RID p_canvas, int p_size, int p_outline_size, const Vector2 &p_pos, uint32_t p_index, const Color &p_color) const { + _THREAD_SAFE_METHOD_ + DataAtSize *fds = const_cast(this)->get_data_for_size(p_size, p_outline_size); + ERR_FAIL_COND_V(fds == nullptr, Vector2()); + + const_cast(this)->update_glyph_outline(p_size, p_outline_size, p_index); + Character ch = fds->glyph_map[p_index]; + + Vector2 advance; + if (ch.found) { + ERR_FAIL_COND_V(ch.texture_idx < -1 || ch.texture_idx >= fds->textures.size(), Vector2()); + + if (ch.texture_idx != -1) { + Point2 cpos = p_pos; + cpos += ch.align; + Color modulate = p_color; + if (FT_HAS_COLOR(fds->face)) { + modulate.r = modulate.g = modulate.b = 1.0; + } + if (RenderingServer::get_singleton() != nullptr) { + RID texture = fds->textures[ch.texture_idx].texture->get_rid(); + RenderingServer::get_singleton()->canvas_item_add_texture_rect_region(p_canvas, Rect2(cpos, ch.rect.size), texture, ch.rect_uv, modulate, false, RID(), RID(), Color(1, 1, 1, 1), false); + } + } + + advance = ch.advance; + } + + return advance; +} + +DynamicFontDataAdvanced::~DynamicFontDataAdvanced() { + clear_cache(); + if (library != nullptr) { + FT_Done_FreeType(library); + } +} diff --git a/modules/text_server_adv/dynamic_font_adv.h b/modules/text_server_adv/dynamic_font_adv.h new file mode 100644 index 0000000000..61cff3cde9 --- /dev/null +++ b/modules/text_server_adv/dynamic_font_adv.h @@ -0,0 +1,188 @@ +/*************************************************************************/ +/* dynamic_font_adv.h */ +/*************************************************************************/ +/* This file is part of: */ +/* GODOT ENGINE */ +/* https://godotengine.org */ +/*************************************************************************/ +/* Copyright (c) 2007-2020 Juan Linietsky, Ariel Manzur. */ +/* Copyright (c) 2014-2020 Godot Engine contributors (cf. AUTHORS.md). */ +/* */ +/* Permission is hereby granted, free of charge, to any person obtaining */ +/* a copy of this software and associated documentation files (the */ +/* "Software"), to deal in the Software without restriction, including */ +/* without limitation the rights to use, copy, modify, merge, publish, */ +/* distribute, sublicense, and/or sell copies of the Software, and to */ +/* permit persons to whom the Software is furnished to do so, subject to */ +/* the following conditions: */ +/* */ +/* The above copyright notice and this permission notice shall be */ +/* included in all copies or substantial portions of the Software. */ +/* */ +/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */ +/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */ +/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/ +/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */ +/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */ +/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */ +/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ +/*************************************************************************/ + +#ifndef DYNAMIC_FONT_ADV_H +#define DYNAMIC_FONT_ADV_H + +#include "font_adv.h" + +#include +#include FT_FREETYPE_H +#include FT_TRUETYPE_TABLES_H + +#include +#include + +struct DynamicFontDataAdvanced : public FontDataAdvanced { + _THREAD_SAFE_CLASS_ + +private: + struct CharTexture { + Vector imgdata; + int texture_size = 0; + Vector offsets; + Ref texture; + }; + + struct Character { + bool found = false; + int texture_idx = 0; + Rect2 rect; + Rect2 rect_uv; + Vector2 align; + Vector2 advance = Vector2(-1, -1); + + static Character not_found(); + }; + + struct TexturePosition { + int index = 0; + int x = 0; + int y = 0; + }; + + struct CacheID { + union { + struct { + uint32_t size : 16; + uint32_t outline_size : 16; + }; + uint32_t key; + }; + bool operator<(CacheID right) const { + return key < right.key; + } + CacheID() { + key = 0; + } + }; + + struct DataAtSize { + FT_Face face = nullptr; + TT_OS2 *os2 = nullptr; + FT_StreamRec stream; + + int size = 0; + float scale_color_font = 1.f; + float ascent = 0; + float descent = 0; + float underline_position = 0; + float underline_thickness = 0; + + Vector textures; + HashMap glyph_map; + + hb_font_t *hb_handle = nullptr; + ~DataAtSize() { + if (hb_handle != nullptr) { + hb_font_destroy(hb_handle); + } + if (face != nullptr) { + FT_Done_Face(face); + } + } + }; + + FT_Library library = nullptr; + + // Source data. + const uint8_t *font_mem = nullptr; + int font_mem_size = 0; + String font_path; + static HashMap> font_mem_cache; + + float rect_margin = 1.f; + int base_size = 16; + float oversampling = 1.f; + bool antialiased = true; + bool force_autohinter = false; + TextServer::Hinting hinting = TextServer::HINTING_LIGHT; + + Map size_cache; + Map size_cache_outline; + + static unsigned long _ft_stream_io(FT_Stream stream, unsigned long offset, unsigned char *buffer, unsigned long count); + static void _ft_stream_close(FT_Stream stream); + + DataAtSize *get_data_for_size(int p_size, int p_outline_size = 0); + + TexturePosition find_texture_pos_for_glyph(DataAtSize *p_data, int p_color_size, Image::Format p_image_format, int p_width, int p_height); + Character bitmap_to_character(DataAtSize *p_data, FT_Bitmap bitmap, int yofs, int xofs, const Vector2 &advance); + _FORCE_INLINE_ void update_glyph(int p_size, uint32_t p_index); + _FORCE_INLINE_ void update_glyph_outline(int p_size, int p_outline_size, uint32_t p_index); + +public: + virtual void clear_cache() override; + + virtual Error load_from_file(const String &p_filename, int p_base_size) override; + virtual Error load_from_memory(const uint8_t *p_data, size_t p_size, int p_base_size) override; + + virtual float get_height(int p_size) const override; + virtual float get_ascent(int p_size) const override; + virtual float get_descent(int p_size) const override; + + virtual Dictionary get_feature_list() const override; + + virtual float get_underline_position(int p_size) const override; + virtual float get_underline_thickness(int p_size) const override; + + virtual void set_antialiased(bool p_antialiased) override; + virtual bool get_antialiased() const override; + + virtual void set_hinting(TextServer::Hinting p_hinting) override; + virtual TextServer::Hinting get_hinting() const override; + + virtual void set_force_autohinter(bool p_enabled) override; + virtual bool get_force_autohinter() const override; + + virtual void set_distance_field_hint(bool p_distance_field) override{}; + virtual bool get_distance_field_hint() const override { return false; }; + + virtual bool has_outline() const override; + virtual float get_base_size() const override; + + virtual bool is_script_supported(uint32_t p_script) const override; + + virtual bool has_char(char32_t p_char) const override; + virtual String get_supported_chars() const override; + virtual float get_font_scale(int p_size) const override; + + virtual hb_font_t *get_hb_handle(int p_size) override; + virtual uint32_t get_glyph_index(char32_t p_char, char32_t p_variation_selector) const override; + virtual Vector2 get_advance(uint32_t p_index, int p_size) const override; + virtual Vector2 get_kerning(uint32_t p_char, uint32_t p_next, int p_size) const override; + + virtual Vector2 draw_glyph(RID p_canvas, int p_size, const Vector2 &p_pos, uint32_t p_index, const Color &p_color) const override; + virtual Vector2 draw_glyph_outline(RID p_canvas, int p_size, int p_outline_size, const Vector2 &p_pos, uint32_t p_index, const Color &p_color) const override; + + virtual ~DynamicFontDataAdvanced() override; +}; + +#endif // DYNAMIC_FONT_ADV_H diff --git a/modules/text_server_adv/font_adv.h b/modules/text_server_adv/font_adv.h new file mode 100644 index 0000000000..232d6d7d08 --- /dev/null +++ b/modules/text_server_adv/font_adv.h @@ -0,0 +1,90 @@ +/*************************************************************************/ +/* font_adv.h */ +/*************************************************************************/ +/* This file is part of: */ +/* GODOT ENGINE */ +/* https://godotengine.org */ +/*************************************************************************/ +/* Copyright (c) 2007-2020 Juan Linietsky, Ariel Manzur. */ +/* Copyright (c) 2014-2020 Godot Engine contributors (cf. AUTHORS.md). */ +/* */ +/* Permission is hereby granted, free of charge, to any person obtaining */ +/* a copy of this software and associated documentation files (the */ +/* "Software"), to deal in the Software without restriction, including */ +/* without limitation the rights to use, copy, modify, merge, publish, */ +/* distribute, sublicense, and/or sell copies of the Software, and to */ +/* permit persons to whom the Software is furnished to do so, subject to */ +/* the following conditions: */ +/* */ +/* The above copyright notice and this permission notice shall be */ +/* included in all copies or substantial portions of the Software. */ +/* */ +/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */ +/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */ +/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/ +/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */ +/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */ +/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */ +/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ +/*************************************************************************/ + +#ifndef FONT_ADV_H +#define FONT_ADV_H + +#include "servers/text_server.h" + +#include + +struct FontDataAdvanced { + Map lang_support_overrides; + Map script_support_overrides; + bool valid = false; + + virtual void clear_cache() = 0; + + virtual Error load_from_file(const String &p_filename, int p_base_size) = 0; + virtual Error load_from_memory(const uint8_t *p_data, size_t p_size, int p_base_size) = 0; + + virtual float get_height(int p_size) const = 0; + virtual float get_ascent(int p_size) const = 0; + virtual float get_descent(int p_size) const = 0; + + virtual Dictionary get_feature_list() const { return Dictionary(); }; + + virtual float get_underline_position(int p_size) const = 0; + virtual float get_underline_thickness(int p_size) const = 0; + + virtual void set_antialiased(bool p_antialiased) = 0; + virtual bool get_antialiased() const = 0; + + virtual void set_hinting(TextServer::Hinting p_hinting) = 0; + virtual TextServer::Hinting get_hinting() const = 0; + + virtual void set_distance_field_hint(bool p_distance_field) = 0; + virtual bool get_distance_field_hint() const = 0; + + virtual void set_force_autohinter(bool p_enabeld) = 0; + virtual bool get_force_autohinter() const = 0; + + virtual bool has_outline() const = 0; + virtual float get_base_size() const = 0; + + virtual bool is_lang_supported(const String &p_lang) const { return false; }; + virtual bool is_script_supported(uint32_t p_script) const { return false; }; + + virtual bool has_char(char32_t p_char) const = 0; + virtual String get_supported_chars() const = 0; + virtual float get_font_scale(int p_size) const { return 1.0f; }; + + virtual hb_font_t *get_hb_handle(int p_size) = 0; + virtual uint32_t get_glyph_index(char32_t p_char, char32_t p_variation_selector) const = 0; + virtual Vector2 get_advance(uint32_t p_char, int p_size) const = 0; + virtual Vector2 get_kerning(uint32_t p_char, uint32_t p_next, int p_size) const = 0; + + virtual Vector2 draw_glyph(RID p_canvas, int p_size, const Vector2 &p_pos, uint32_t p_index, const Color &p_color) const = 0; + virtual Vector2 draw_glyph_outline(RID p_canvas, int p_size, int p_outline_size, const Vector2 &p_pos, uint32_t p_index, const Color &p_color) const = 0; + + virtual ~FontDataAdvanced(){}; +}; + +#endif // FONT_ADV_H diff --git a/modules/text_server_adv/register_types.cpp b/modules/text_server_adv/register_types.cpp new file mode 100644 index 0000000000..68117e0380 --- /dev/null +++ b/modules/text_server_adv/register_types.cpp @@ -0,0 +1,43 @@ +/*************************************************************************/ +/* register_types.cpp */ +/*************************************************************************/ +/* This file is part of: */ +/* GODOT ENGINE */ +/* https://godotengine.org */ +/*************************************************************************/ +/* Copyright (c) 2007-2020 Juan Linietsky, Ariel Manzur. */ +/* Copyright (c) 2014-2020 Godot Engine contributors (cf. AUTHORS.md). */ +/* */ +/* Permission is hereby granted, free of charge, to any person obtaining */ +/* a copy of this software and associated documentation files (the */ +/* "Software"), to deal in the Software without restriction, including */ +/* without limitation the rights to use, copy, modify, merge, publish, */ +/* distribute, sublicense, and/or sell copies of the Software, and to */ +/* permit persons to whom the Software is furnished to do so, subject to */ +/* the following conditions: */ +/* */ +/* The above copyright notice and this permission notice shall be */ +/* included in all copies or substantial portions of the Software. */ +/* */ +/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */ +/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */ +/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/ +/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */ +/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */ +/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */ +/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ +/*************************************************************************/ + +#include "register_types.h" + +#include "text_server_adv.h" + +void preregister_text_server_adv_types() { + TextServerAdvanced::register_server(); +} + +void register_text_server_adv_types() { +} + +void unregister_text_server_adv_types() { +} diff --git a/modules/text_server_adv/register_types.h b/modules/text_server_adv/register_types.h new file mode 100644 index 0000000000..8319ddfd5d --- /dev/null +++ b/modules/text_server_adv/register_types.h @@ -0,0 +1,40 @@ +/*************************************************************************/ +/* register_types.h */ +/*************************************************************************/ +/* This file is part of: */ +/* GODOT ENGINE */ +/* https://godotengine.org */ +/*************************************************************************/ +/* Copyright (c) 2007-2020 Juan Linietsky, Ariel Manzur. */ +/* Copyright (c) 2014-2020 Godot Engine contributors (cf. AUTHORS.md). */ +/* */ +/* Permission is hereby granted, free of charge, to any person obtaining */ +/* a copy of this software and associated documentation files (the */ +/* "Software"), to deal in the Software without restriction, including */ +/* without limitation the rights to use, copy, modify, merge, publish, */ +/* distribute, sublicense, and/or sell copies of the Software, and to */ +/* permit persons to whom the Software is furnished to do so, subject to */ +/* the following conditions: */ +/* */ +/* The above copyright notice and this permission notice shall be */ +/* included in all copies or substantial portions of the Software. */ +/* */ +/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */ +/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */ +/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/ +/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */ +/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */ +/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */ +/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ +/*************************************************************************/ + +#ifndef TEXT_SERVER_ADV_REGISTER_TYPES_H +#define TEXT_SERVER_ADV_REGISTER_TYPES_H + +#define MODULE_TEXT_SERVER_ADV_HAS_PREREGISTER + +void preregister_text_server_adv_types(); +void register_text_server_adv_types(); +void unregister_text_server_adv_types(); + +#endif // TEXT_SERVER_ADV_REGISTER_TYPES_H diff --git a/modules/text_server_adv/script_iterator.cpp b/modules/text_server_adv/script_iterator.cpp new file mode 100644 index 0000000000..8a2b2cced0 --- /dev/null +++ b/modules/text_server_adv/script_iterator.cpp @@ -0,0 +1,109 @@ +/*************************************************************************/ +/* script_iterator.cpp */ +/*************************************************************************/ +/* This file is part of: */ +/* GODOT ENGINE */ +/* https://godotengine.org */ +/*************************************************************************/ +/* Copyright (c) 2007-2020 Juan Linietsky, Ariel Manzur. */ +/* Copyright (c) 2014-2020 Godot Engine contributors (cf. AUTHORS.md). */ +/* */ +/* Permission is hereby granted, free of charge, to any person obtaining */ +/* a copy of this software and associated documentation files (the */ +/* "Software"), to deal in the Software without restriction, including */ +/* without limitation the rights to use, copy, modify, merge, publish, */ +/* distribute, sublicense, and/or sell copies of the Software, and to */ +/* permit persons to whom the Software is furnished to do so, subject to */ +/* the following conditions: */ +/* */ +/* The above copyright notice and this permission notice shall be */ +/* included in all copies or substantial portions of the Software. */ +/* */ +/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */ +/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */ +/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/ +/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */ +/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */ +/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */ +/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ +/*************************************************************************/ + +#include "script_iterator.h" + +bool ScriptIterator::same_script(int32_t p_script_one, int32_t p_script_two) { + return p_script_one <= USCRIPT_INHERITED || p_script_two <= USCRIPT_INHERITED || p_script_one == p_script_two; +} + +ScriptIterator::ScriptIterator(const String &p_string, int p_start, int p_length) { + struct ParenStackEntry { + int pair_index; + UScriptCode script_code; + }; + + if (p_start >= p_length) { + p_start = p_length - 1; + } + + if (p_start < 0) { + p_start = 0; + } + + ParenStackEntry paren_stack[128]; + + int script_start; + int script_end = p_start; + UScriptCode script_code; + int paren_sp = -1; + int start_sp = paren_sp; + UErrorCode err = U_ZERO_ERROR; + + do { + script_code = USCRIPT_COMMON; + for (script_start = script_end; script_end < p_length; script_end++) { + UChar32 ch = p_string[script_end]; + UScriptCode sc = uscript_getScript(ch, &err); + if (U_FAILURE(err)) { + ERR_FAIL_MSG(u_errorName(err)); + } + if (u_getIntPropertyValue(ch, UCHAR_BIDI_PAIRED_BRACKET_TYPE) != U_BPT_NONE) { + if (u_getIntPropertyValue(ch, UCHAR_BIDI_PAIRED_BRACKET_TYPE) == U_BPT_OPEN) { + paren_stack[++paren_sp].pair_index = ch; + paren_stack[paren_sp].script_code = script_code; + } else if (paren_sp >= 0) { + UChar32 paired_ch = u_getBidiPairedBracket(ch); + while (paren_sp >= 0 && paren_stack[paren_sp].pair_index != paired_ch) { + paren_sp -= 1; + } + if (paren_sp < start_sp) + start_sp = paren_sp; + if (paren_sp >= 0) + sc = paren_stack[paren_sp].script_code; + } + } + + if (same_script(script_code, sc)) { + if (script_code <= USCRIPT_INHERITED && sc > USCRIPT_INHERITED) { + script_code = sc; + while (start_sp < paren_sp) { + paren_stack[++start_sp].script_code = script_code; + } + } + if ((u_getIntPropertyValue(ch, UCHAR_BIDI_PAIRED_BRACKET_TYPE) == U_BPT_CLOSE) && paren_sp >= 0) { + paren_sp -= 1; + if (start_sp >= 0) { + start_sp -= 1; + } + } + } else { + break; + } + } + + ScriptRange rng; + rng.script = hb_icu_script_to_script(script_code); + rng.start = script_start; + rng.end = script_end; + + script_ranges.push_back(rng); + } while (script_end < p_length); +} diff --git a/modules/text_server_adv/script_iterator.h b/modules/text_server_adv/script_iterator.h new file mode 100644 index 0000000000..4523aa2767 --- /dev/null +++ b/modules/text_server_adv/script_iterator.h @@ -0,0 +1,61 @@ +/*************************************************************************/ +/* script_iterator.h */ +/*************************************************************************/ +/* This file is part of: */ +/* GODOT ENGINE */ +/* https://godotengine.org */ +/*************************************************************************/ +/* Copyright (c) 2007-2020 Juan Linietsky, Ariel Manzur. */ +/* Copyright (c) 2014-2020 Godot Engine contributors (cf. AUTHORS.md). */ +/* */ +/* Permission is hereby granted, free of charge, to any person obtaining */ +/* a copy of this software and associated documentation files (the */ +/* "Software"), to deal in the Software without restriction, including */ +/* without limitation the rights to use, copy, modify, merge, publish, */ +/* distribute, sublicense, and/or sell copies of the Software, and to */ +/* permit persons to whom the Software is furnished to do so, subject to */ +/* the following conditions: */ +/* */ +/* The above copyright notice and this permission notice shall be */ +/* included in all copies or substantial portions of the Software. */ +/* */ +/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */ +/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */ +/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/ +/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */ +/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */ +/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */ +/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ +/*************************************************************************/ + +#ifndef SCRIPT_ITERATOR_H +#define SCRIPT_ITERATOR_H + +#include "servers/text_server.h" + +#include +#include +#include +#include +#include + +#include +#include + +class ScriptIterator { +public: + struct ScriptRange { + int start; + int end; + hb_script_t script; + }; + Vector script_ranges; + +private: + static bool same_script(int32_t p_script_one, int32_t p_script_two); + +public: + ScriptIterator(const String &p_string, int p_start, int p_length); +}; + +#endif //SCRIPT_ITERATOR_H diff --git a/modules/text_server_adv/text_server_adv.cpp b/modules/text_server_adv/text_server_adv.cpp new file mode 100644 index 0000000000..e391777eea --- /dev/null +++ b/modules/text_server_adv/text_server_adv.cpp @@ -0,0 +1,2520 @@ +/*************************************************************************/ +/* text_server_adv.cpp */ +/*************************************************************************/ +/* This file is part of: */ +/* GODOT ENGINE */ +/* https://godotengine.org */ +/*************************************************************************/ +/* Copyright (c) 2007-2020 Juan Linietsky, Ariel Manzur. */ +/* Copyright (c) 2014-2020 Godot Engine contributors (cf. AUTHORS.md). */ +/* */ +/* Permission is hereby granted, free of charge, to any person obtaining */ +/* a copy of this software and associated documentation files (the */ +/* "Software"), to deal in the Software without restriction, including */ +/* without limitation the rights to use, copy, modify, merge, publish, */ +/* distribute, sublicense, and/or sell copies of the Software, and to */ +/* permit persons to whom the Software is furnished to do so, subject to */ +/* the following conditions: */ +/* */ +/* The above copyright notice and this permission notice shall be */ +/* included in all copies or substantial portions of the Software. */ +/* */ +/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */ +/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */ +/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/ +/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */ +/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */ +/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */ +/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ +/*************************************************************************/ + +#include "text_server_adv.h" +#include "bitmap_font_adv.h" +#include "dynamic_font_adv.h" + +#include "core/string/translation.h" + +#ifdef ICU_STATIC_DATA +#include "thirdparty/icu4c/icudata.gen.h" +#endif + +_FORCE_INLINE_ bool is_ain(char32_t p_chr) { + return u_getIntPropertyValue(p_chr, UCHAR_JOINING_GROUP) == U_JG_AIN; +} + +_FORCE_INLINE_ bool is_alef(char32_t p_chr) { + return u_getIntPropertyValue(p_chr, UCHAR_JOINING_GROUP) == U_JG_ALEF; +} + +_FORCE_INLINE_ bool is_beh(char32_t p_chr) { + int32_t prop = u_getIntPropertyValue(p_chr, UCHAR_JOINING_GROUP); + return (prop == U_JG_BEH) || (prop == U_JG_NOON) || (prop == U_JG_AFRICAN_NOON) || (prop == U_JG_NYA) || (prop == U_JG_YEH) || (prop == U_JG_FARSI_YEH); +} + +_FORCE_INLINE_ bool is_dal(char32_t p_chr) { + return u_getIntPropertyValue(p_chr, UCHAR_JOINING_GROUP) == U_JG_DAL; +} + +_FORCE_INLINE_ bool is_feh(char32_t p_chr) { + return (u_getIntPropertyValue(p_chr, UCHAR_JOINING_GROUP) == U_JG_FEH) || (u_getIntPropertyValue(p_chr, UCHAR_JOINING_GROUP) == U_JG_AFRICAN_FEH); +} + +_FORCE_INLINE_ bool is_gaf(char32_t p_chr) { + return u_getIntPropertyValue(p_chr, UCHAR_JOINING_GROUP) == U_JG_GAF; +} + +_FORCE_INLINE_ bool is_heh(char32_t p_chr) { + return u_getIntPropertyValue(p_chr, UCHAR_JOINING_GROUP) == U_JG_HEH; +} + +_FORCE_INLINE_ bool is_kaf(char32_t p_chr) { + return u_getIntPropertyValue(p_chr, UCHAR_JOINING_GROUP) == U_JG_KAF; +} + +_FORCE_INLINE_ bool is_lam(char32_t p_chr) { + return u_getIntPropertyValue(p_chr, UCHAR_JOINING_GROUP) == U_JG_LAM; +} + +_FORCE_INLINE_ bool is_qaf(char32_t p_chr) { + return (u_getIntPropertyValue(p_chr, UCHAR_JOINING_GROUP) == U_JG_QAF) || (u_getIntPropertyValue(p_chr, UCHAR_JOINING_GROUP) == U_JG_AFRICAN_QAF); +} + +_FORCE_INLINE_ bool is_reh(char32_t p_chr) { + return u_getIntPropertyValue(p_chr, UCHAR_JOINING_GROUP) == U_JG_REH; +} + +_FORCE_INLINE_ bool is_seen_sad(char32_t p_chr) { + return (u_getIntPropertyValue(p_chr, UCHAR_JOINING_GROUP) == U_JG_SAD) || (u_getIntPropertyValue(p_chr, UCHAR_JOINING_GROUP) == U_JG_SEEN); +} + +_FORCE_INLINE_ bool is_tah(char32_t p_chr) { + return u_getIntPropertyValue(p_chr, UCHAR_JOINING_GROUP) == U_JG_TAH; +} + +_FORCE_INLINE_ bool is_teh_marbuta(char32_t p_chr) { + return u_getIntPropertyValue(p_chr, UCHAR_JOINING_GROUP) == U_JG_TEH_MARBUTA; +} + +_FORCE_INLINE_ bool is_yeh(char32_t p_chr) { + int32_t prop = u_getIntPropertyValue(p_chr, UCHAR_JOINING_GROUP); + return (prop == U_JG_YEH) || (prop == U_JG_FARSI_YEH) || (prop == U_JG_YEH_BARREE) || (prop == U_JG_BURUSHASKI_YEH_BARREE) || (prop == U_JG_YEH_WITH_TAIL); +} + +_FORCE_INLINE_ bool is_waw(char32_t p_chr) { + return u_getIntPropertyValue(p_chr, UCHAR_JOINING_GROUP) == U_JG_WAW; +} + +_FORCE_INLINE_ bool is_transparent(char32_t p_chr) { + return u_getIntPropertyValue(p_chr, UCHAR_JOINING_TYPE) == U_JT_TRANSPARENT; +} + +_FORCE_INLINE_ bool is_ligature(char32_t p_chr, char32_t p_nchr) { + return (is_lam(p_chr) && is_alef(p_nchr)); +} + +_FORCE_INLINE_ bool is_connected_to_prev(char32_t p_chr, char32_t p_pchr) { + int32_t prop = u_getIntPropertyValue(p_pchr, UCHAR_JOINING_TYPE); + return (prop != U_JT_RIGHT_JOINING) && (prop != U_JT_NON_JOINING) ? !is_ligature(p_pchr, p_chr) : false; +} + +_FORCE_INLINE_ bool is_control(char32_t p_char) { + return (p_char <= 0x001f) || (p_char >= 0x007f && p_char <= 0x009F); +} + +_FORCE_INLINE_ bool is_whitespace(char32_t p_char) { + return (p_char == 0x0020) || (p_char == 0x00A0) || (p_char == 0x1680) || (p_char >= 0x2000 && p_char <= 0x200a) || (p_char == 0x202f) || (p_char == 0x205f) || (p_char == 0x3000) || (p_char == 0x2028) || (p_char == 0x2029) || (p_char >= 0x0009 && p_char <= 0x000d) || (p_char == 0x0085); +} + +_FORCE_INLINE_ bool is_linebreak(char32_t p_char) { + return (p_char >= 0x000a && p_char <= 0x000d) || (p_char == 0x0085) || (p_char == 0x2028) || (p_char == 0x2029); +} + +/*************************************************************************/ + +String TextServerAdvanced::interface_name = "ICU / HarfBuzz / Graphite"; +uint32_t TextServerAdvanced::interface_features = FEATURE_BIDI_LAYOUT | FEATURE_VERTICAL_LAYOUT | FEATURE_SHAPING | FEATURE_KASHIDA_JUSTIFICATION | FEATURE_BREAK_ITERATORS | FEATURE_USE_SUPPORT_DATA; + +bool TextServerAdvanced::has_feature(Feature p_feature) { + return (interface_features & p_feature) == p_feature; +} + +String TextServerAdvanced::get_name() const { + return interface_name; +} + +void TextServerAdvanced::free(RID p_rid) { + _THREAD_SAFE_METHOD_ + if (font_owner.owns(p_rid)) { + FontDataAdvanced *fd = font_owner.getornull(p_rid); + font_owner.free(p_rid); + memdelete(fd); + } else if (shaped_owner.owns(p_rid)) { + ShapedTextDataAdvanced *sd = shaped_owner.getornull(p_rid); + shaped_owner.free(p_rid); + memdelete(sd); + } +} + +bool TextServerAdvanced::has(RID p_rid) { + _THREAD_SAFE_METHOD_ + return font_owner.owns(p_rid) || shaped_owner.owns(p_rid); +} + +bool TextServerAdvanced::load_support_data(const String &p_filename) { + _THREAD_SAFE_METHOD_ + +#ifdef ICU_STATIC_DATA + if (icu_data == nullptr) { + UErrorCode err = U_ZERO_ERROR; + u_init(&err); // Do not check for errors, since we only load part the of data. + icu_data = (uint8_t *)&U_ICUDATA_ENTRY_POINT; + } +#else + if (icu_data == nullptr) { + String filename = (p_filename.empty()) ? String("res://") + _MKSTR(ICU_DATA_NAME) : p_filename; + + FileAccess *f = FileAccess::open(filename, FileAccess::READ); + if (!f) { + return false; + } + + UErrorCode err = U_ZERO_ERROR; + + // ICU data found. + size_t len = f->get_len(); + icu_data = (uint8_t *)memalloc(len); + f->get_buffer(icu_data, len); + f->close(); + memdelete(f); + + udata_setCommonData(icu_data, &err); + if (U_FAILURE(err)) { + memfree(icu_data); + icu_data = nullptr; + ERR_FAIL_V_MSG(false, u_errorName(err)); + } + + err = U_ZERO_ERROR; + u_init(&err); + if (U_FAILURE(err)) { + memfree(icu_data); + icu_data = nullptr; + ERR_FAIL_V_MSG(false, u_errorName(err)); + } + } +#endif + return true; +} + +#ifdef TOOLS_ENABLED + +bool TextServerAdvanced::save_support_data(const String &p_filename) { + _THREAD_SAFE_METHOD_ +#ifdef ICU_STATIC_DATA + + // Store data to the res file if it's available. + FileAccess *f = FileAccess::open(p_filename, FileAccess::WRITE); + if (!f) { + return false; + } + f->store_buffer(U_ICUDATA_ENTRY_POINT, U_ICUDATA_SIZE); + f->close(); + memdelete(f); + return true; + +#else + return false; +#endif +} + +#endif + +bool TextServerAdvanced::is_locale_right_to_left(const String &p_locale) { + String l = p_locale.get_slicec('_', 0); + if ((l == "ar") || (l == "dv") || (l == "he") || (l == "fa") || (l == "ff") || (l == "ku") || (l == "ur")) { + return true; + } else { + return false; + } +} + +struct FeatureInfo { + int32_t tag; + String name; +}; + +static FeatureInfo feature_set[] = { + // Registred OpenType feature tags. + { HB_TAG('a', 'a', 'l', 't'), "access_all_alternates" }, + { HB_TAG('a', 'b', 'v', 'f'), "above_base_forms" }, + { HB_TAG('a', 'b', 'v', 'm'), "above_base_mark_positioning" }, + { HB_TAG('a', 'b', 'v', 's'), "above_base_substitutions" }, + { HB_TAG('a', 'f', 'r', 'c'), "alternative_fractions" }, + { HB_TAG('a', 'k', 'h', 'n'), "akhands" }, + { HB_TAG('b', 'l', 'w', 'f'), "below_base_forms" }, + { HB_TAG('b', 'l', 'w', 'm'), "below_base_mark_positioning" }, + { HB_TAG('b', 'l', 'w', 's'), "below_base_substitutions" }, + { HB_TAG('c', 'a', 'l', 't'), "contextual_alternates" }, + { HB_TAG('c', 'a', 's', 'e'), "case_sensitive_forms" }, + { HB_TAG('c', 'c', 'm', 'p'), "glyph_composition" }, + { HB_TAG('c', 'f', 'a', 'r'), "conjunct_form_after_ro" }, + { HB_TAG('c', 'j', 'c', 't'), "conjunct_forms" }, + { HB_TAG('c', 'l', 'i', 'g'), "contextual_ligatures" }, + { HB_TAG('c', 'p', 'c', 't'), "centered_cjk_punctuation" }, + { HB_TAG('c', 'p', 's', 'p'), "capital_spacing" }, + { HB_TAG('c', 's', 'w', 'h'), "contextual_swash" }, + { HB_TAG('c', 'u', 'r', 's'), "cursive_positioning" }, + { HB_TAG('c', 'v', '0', '1'), "character_variant_01" }, + { HB_TAG('c', 'v', '0', '2'), "character_variant_02" }, + { HB_TAG('c', 'v', '0', '3'), "character_variant_03" }, + { HB_TAG('c', 'v', '0', '4'), "character_variant_04" }, + { HB_TAG('c', 'v', '0', '5'), "character_variant_05" }, + { HB_TAG('c', 'v', '0', '6'), "character_variant_06" }, + { HB_TAG('c', 'v', '0', '7'), "character_variant_07" }, + { HB_TAG('c', 'v', '0', '8'), "character_variant_08" }, + { HB_TAG('c', 'v', '0', '9'), "character_variant_09" }, + { HB_TAG('c', 'v', '1', '0'), "character_variant_10" }, + { HB_TAG('c', 'v', '1', '1'), "character_variant_11" }, + { HB_TAG('c', 'v', '1', '2'), "character_variant_12" }, + { HB_TAG('c', 'v', '1', '3'), "character_variant_13" }, + { HB_TAG('c', 'v', '1', '4'), "character_variant_14" }, + { HB_TAG('c', 'v', '1', '5'), "character_variant_15" }, + { HB_TAG('c', 'v', '1', '6'), "character_variant_16" }, + { HB_TAG('c', 'v', '1', '7'), "character_variant_17" }, + { HB_TAG('c', 'v', '1', '8'), "character_variant_18" }, + { HB_TAG('c', 'v', '1', '9'), "character_variant_19" }, + { HB_TAG('c', 'v', '2', '0'), "character_variant_20" }, + { HB_TAG('c', 'v', '2', '1'), "character_variant_21" }, + { HB_TAG('c', 'v', '2', '2'), "character_variant_22" }, + { HB_TAG('c', 'v', '2', '3'), "character_variant_23" }, + { HB_TAG('c', 'v', '2', '4'), "character_variant_24" }, + { HB_TAG('c', 'v', '2', '5'), "character_variant_25" }, + { HB_TAG('c', 'v', '2', '6'), "character_variant_26" }, + { HB_TAG('c', 'v', '2', '7'), "character_variant_27" }, + { HB_TAG('c', 'v', '2', '8'), "character_variant_28" }, + { HB_TAG('c', 'v', '2', '9'), "character_variant_29" }, + { HB_TAG('c', 'v', '3', '0'), "character_variant_30" }, + { HB_TAG('c', 'v', '3', '1'), "character_variant_31" }, + { HB_TAG('c', 'v', '3', '2'), "character_variant_32" }, + { HB_TAG('c', 'v', '3', '3'), "character_variant_33" }, + { HB_TAG('c', 'v', '3', '4'), "character_variant_34" }, + { HB_TAG('c', 'v', '3', '5'), "character_variant_35" }, + { HB_TAG('c', 'v', '3', '6'), "character_variant_36" }, + { HB_TAG('c', 'v', '3', '7'), "character_variant_37" }, + { HB_TAG('c', 'v', '3', '8'), "character_variant_38" }, + { HB_TAG('c', 'v', '3', '9'), "character_variant_39" }, + { HB_TAG('c', 'v', '4', '0'), "character_variant_40" }, + { HB_TAG('c', 'v', '4', '1'), "character_variant_41" }, + { HB_TAG('c', 'v', '4', '2'), "character_variant_42" }, + { HB_TAG('c', 'v', '4', '3'), "character_variant_43" }, + { HB_TAG('c', 'v', '4', '4'), "character_variant_44" }, + { HB_TAG('c', 'v', '4', '5'), "character_variant_45" }, + { HB_TAG('c', 'v', '4', '6'), "character_variant_46" }, + { HB_TAG('c', 'v', '4', '7'), "character_variant_47" }, + { HB_TAG('c', 'v', '4', '8'), "character_variant_48" }, + { HB_TAG('c', 'v', '4', '9'), "character_variant_49" }, + { HB_TAG('c', 'v', '5', '0'), "character_variant_50" }, + { HB_TAG('c', 'v', '5', '1'), "character_variant_51" }, + { HB_TAG('c', 'v', '5', '2'), "character_variant_52" }, + { HB_TAG('c', 'v', '5', '3'), "character_variant_53" }, + { HB_TAG('c', 'v', '5', '4'), "character_variant_54" }, + { HB_TAG('c', 'v', '5', '5'), "character_variant_55" }, + { HB_TAG('c', 'v', '5', '6'), "character_variant_56" }, + { HB_TAG('c', 'v', '5', '7'), "character_variant_57" }, + { HB_TAG('c', 'v', '5', '8'), "character_variant_58" }, + { HB_TAG('c', 'v', '5', '9'), "character_variant_59" }, + { HB_TAG('c', 'v', '6', '0'), "character_variant_60" }, + { HB_TAG('c', 'v', '6', '1'), "character_variant_61" }, + { HB_TAG('c', 'v', '6', '2'), "character_variant_62" }, + { HB_TAG('c', 'v', '6', '3'), "character_variant_63" }, + { HB_TAG('c', 'v', '6', '4'), "character_variant_64" }, + { HB_TAG('c', 'v', '6', '5'), "character_variant_65" }, + { HB_TAG('c', 'v', '6', '6'), "character_variant_66" }, + { HB_TAG('c', 'v', '6', '7'), "character_variant_67" }, + { HB_TAG('c', 'v', '6', '8'), "character_variant_68" }, + { HB_TAG('c', 'v', '6', '9'), "character_variant_69" }, + { HB_TAG('c', 'v', '7', '0'), "character_variant_70" }, + { HB_TAG('c', 'v', '7', '1'), "character_variant_71" }, + { HB_TAG('c', 'v', '7', '2'), "character_variant_72" }, + { HB_TAG('c', 'v', '7', '3'), "character_variant_73" }, + { HB_TAG('c', 'v', '7', '4'), "character_variant_74" }, + { HB_TAG('c', 'v', '7', '5'), "character_variant_75" }, + { HB_TAG('c', 'v', '7', '6'), "character_variant_76" }, + { HB_TAG('c', 'v', '7', '7'), "character_variant_77" }, + { HB_TAG('c', 'v', '7', '8'), "character_variant_78" }, + { HB_TAG('c', 'v', '7', '9'), "character_variant_79" }, + { HB_TAG('c', 'v', '8', '0'), "character_variant_80" }, + { HB_TAG('c', 'v', '8', '1'), "character_variant_81" }, + { HB_TAG('c', 'v', '8', '2'), "character_variant_82" }, + { HB_TAG('c', 'v', '8', '3'), "character_variant_83" }, + { HB_TAG('c', 'v', '8', '4'), "character_variant_84" }, + { HB_TAG('c', 'v', '8', '5'), "character_variant_85" }, + { HB_TAG('c', 'v', '8', '6'), "character_variant_86" }, + { HB_TAG('c', 'v', '8', '7'), "character_variant_87" }, + { HB_TAG('c', 'v', '8', '8'), "character_variant_88" }, + { HB_TAG('c', 'v', '8', '9'), "character_variant_89" }, + { HB_TAG('c', 'v', '9', '0'), "character_variant_90" }, + { HB_TAG('c', 'v', '9', '1'), "character_variant_91" }, + { HB_TAG('c', 'v', '9', '2'), "character_variant_92" }, + { HB_TAG('c', 'v', '9', '3'), "character_variant_93" }, + { HB_TAG('c', 'v', '9', '4'), "character_variant_94" }, + { HB_TAG('c', 'v', '9', '5'), "character_variant_95" }, + { HB_TAG('c', 'v', '9', '6'), "character_variant_96" }, + { HB_TAG('c', 'v', '9', '7'), "character_variant_97" }, + { HB_TAG('c', 'v', '9', '8'), "character_variant_98" }, + { HB_TAG('c', 'v', '9', '9'), "character_variant_99" }, + { HB_TAG('c', '2', 'p', 'c'), "petite_capitals_from_capitals" }, + { HB_TAG('c', '2', 's', 'c'), "small_capitals_from_capitals" }, + { HB_TAG('d', 'i', 's', 't'), "distances" }, + { HB_TAG('d', 'l', 'i', 'g'), "discretionary_ligatures" }, + { HB_TAG('d', 'n', 'o', 'm'), "denominators" }, + { HB_TAG('d', 't', 'l', 's'), "dotless_forms" }, + { HB_TAG('e', 'x', 'p', 't'), "expert_forms" }, + { HB_TAG('f', 'a', 'l', 't'), "final_glyph_on_line_alternates" }, + { HB_TAG('f', 'i', 'n', '2'), "terminal_forms_2" }, + { HB_TAG('f', 'i', 'n', '3'), "terminal_forms_3" }, + { HB_TAG('f', 'i', 'n', 'a'), "terminal_forms" }, + { HB_TAG('f', 'l', 'a', 'c'), "flattened_accent_forms" }, + { HB_TAG('f', 'r', 'a', 'c'), "fractions" }, + { HB_TAG('f', 'w', 'i', 'd'), "full_widths" }, + { HB_TAG('h', 'a', 'l', 'f'), "half_forms" }, + { HB_TAG('h', 'a', 'l', 'n'), "halant_forms" }, + { HB_TAG('h', 'a', 'l', 't'), "alternate_half_widths" }, + { HB_TAG('h', 'i', 's', 't'), "historical_forms" }, + { HB_TAG('h', 'k', 'n', 'a'), "horizontal_kana_alternates" }, + { HB_TAG('h', 'l', 'i', 'g'), "historical_ligatures" }, + { HB_TAG('h', 'n', 'g', 'l'), "hangul" }, + { HB_TAG('h', 'o', 'j', 'o'), "hojo_kanji_forms" }, + { HB_TAG('h', 'w', 'i', 'd'), "half_widths" }, + { HB_TAG('i', 'n', 'i', 't'), "initial_forms" }, + { HB_TAG('i', 's', 'o', 'l'), "isolated_forms" }, + { HB_TAG('i', 't', 'a', 'l'), "italics" }, + { HB_TAG('j', 'a', 'l', 't'), "justification_alternates" }, + { HB_TAG('j', 'p', '7', '8'), "jis78_forms" }, + { HB_TAG('j', 'p', '8', '3'), "jis83_forms" }, + { HB_TAG('j', 'p', '9', '0'), "jis90_forms" }, + { HB_TAG('j', 'p', '0', '4'), "jis2004_forms" }, + { HB_TAG('k', 'e', 'r', 'n'), "kerning" }, + { HB_TAG('l', 'f', 'b', 'd'), "left_bounds" }, + { HB_TAG('l', 'i', 'g', 'a'), "standard_ligatures" }, + { HB_TAG('l', 'j', 'm', 'o'), "leading_jamo_forms" }, + { HB_TAG('l', 'n', 'u', 'm'), "lining_figures" }, + { HB_TAG('l', 'o', 'c', 'l'), "localized_forms" }, + { HB_TAG('l', 't', 'r', 'a'), "left_to_right_alternates" }, + { HB_TAG('l', 't', 'r', 'm'), "left_to_right_mirrored_forms" }, + { HB_TAG('m', 'a', 'r', 'k'), "mark_positioning" }, + { HB_TAG('m', 'e', 'd', '2'), "medial_forms_2" }, + { HB_TAG('m', 'e', 'd', 'i'), "medial_forms" }, + { HB_TAG('m', 'g', 'r', 'k'), "mathematical_greek" }, + { HB_TAG('m', 'k', 'm', 'k'), "mark_to_mark_positioning" }, + { HB_TAG('m', 's', 'e', 't'), "mark_positioning_via_substitution" }, + { HB_TAG('n', 'a', 'l', 't'), "alternate_annotation_forms" }, + { HB_TAG('n', 'l', 'c', 'k'), "nlc_kanji_forms" }, + { HB_TAG('n', 'u', 'k', 't'), "nukta_forms" }, + { HB_TAG('n', 'u', 'm', 'r'), "numerators" }, + { HB_TAG('o', 'n', 'u', 'm'), "oldstyle_figures" }, + { HB_TAG('o', 'p', 'b', 'd'), "optical_bounds" }, + { HB_TAG('o', 'r', 'd', 'n'), "ordinals" }, + { HB_TAG('o', 'r', 'n', 'm'), "ornaments" }, + { HB_TAG('p', 'a', 'l', 't'), "proportional_alternate_widths" }, + { HB_TAG('p', 'c', 'a', 'p'), "petite_capitals" }, + { HB_TAG('p', 'k', 'n', 'a'), "proportional_kana" }, + { HB_TAG('p', 'n', 'u', 'm'), "proportional_figures" }, + { HB_TAG('p', 'r', 'e', 'f'), "pre_base_forms" }, + { HB_TAG('p', 'r', 'e', 's'), "pre_base_substitutions" }, + { HB_TAG('p', 's', 't', 'f'), "post_base_forms" }, + { HB_TAG('p', 's', 't', 's'), "post_base_substitutions" }, + { HB_TAG('p', 'w', 'i', 'd'), "proportional_widths" }, + { HB_TAG('q', 'w', 'i', 'd'), "quarter_widths" }, + { HB_TAG('r', 'a', 'n', 'd'), "randomize" }, + { HB_TAG('r', 'c', 'l', 't'), "required_contextual_alternates" }, + { HB_TAG('r', 'k', 'r', 'f'), "rakar_forms" }, + { HB_TAG('r', 'l', 'i', 'g'), "required_ligatures" }, + { HB_TAG('r', 'p', 'h', 'f'), "reph_forms" }, + { HB_TAG('r', 't', 'b', 'd'), "right_bounds" }, + { HB_TAG('r', 't', 'l', 'a'), "right_to_left_alternates" }, + { HB_TAG('r', 't', 'l', 'm'), "right_to_left_mirrored_forms" }, + { HB_TAG('r', 'u', 'b', 'y'), "ruby_notation_forms" }, + { HB_TAG('r', 'v', 'r', 'n'), "required_variation_alternates" }, + { HB_TAG('s', 'a', 'l', 't'), "stylistic_alternates" }, + { HB_TAG('s', 'i', 'n', 'f'), "scientific_inferiors" }, + { HB_TAG('s', 'i', 'z', 'e'), "optical_size" }, + { HB_TAG('s', 'm', 'c', 'p'), "small_capitals" }, + { HB_TAG('s', 'm', 'p', 'l'), "simplified_forms" }, + { HB_TAG('s', 's', '0', '1'), "stylistic_set_01" }, + { HB_TAG('s', 's', '0', '2'), "stylistic_set_02" }, + { HB_TAG('s', 's', '0', '3'), "stylistic_set_03" }, + { HB_TAG('s', 's', '0', '4'), "stylistic_set_04" }, + { HB_TAG('s', 's', '0', '5'), "stylistic_set_05" }, + { HB_TAG('s', 's', '0', '6'), "stylistic_set_06" }, + { HB_TAG('s', 's', '0', '7'), "stylistic_set_07" }, + { HB_TAG('s', 's', '0', '8'), "stylistic_set_08" }, + { HB_TAG('s', 's', '0', '9'), "stylistic_set_09" }, + { HB_TAG('s', 's', '1', '0'), "stylistic_set_10" }, + { HB_TAG('s', 's', '1', '1'), "stylistic_set_11" }, + { HB_TAG('s', 's', '1', '2'), "stylistic_set_12" }, + { HB_TAG('s', 's', '1', '3'), "stylistic_set_13" }, + { HB_TAG('s', 's', '1', '4'), "stylistic_set_14" }, + { HB_TAG('s', 's', '1', '5'), "stylistic_set_15" }, + { HB_TAG('s', 's', '1', '6'), "stylistic_set_16" }, + { HB_TAG('s', 's', '1', '7'), "stylistic_set_17" }, + { HB_TAG('s', 's', '1', '8'), "stylistic_set_18" }, + { HB_TAG('s', 's', '1', '9'), "stylistic_set_19" }, + { HB_TAG('s', 's', '2', '0'), "stylistic_set_20" }, + { HB_TAG('s', 's', 't', 'y'), "math_script_style_alternates" }, + { HB_TAG('s', 't', 'c', 'h'), "stretching_glyph_decomposition" }, + { HB_TAG('s', 'u', 'b', 's'), "subscript" }, + { HB_TAG('s', 'u', 'p', 's'), "superscript" }, + { HB_TAG('s', 'w', 's', 'h'), "swash" }, + { HB_TAG('t', 'i', 't', 'l'), "titling" }, + { HB_TAG('t', 'j', 'm', 'o'), "trailing_jamo_forms" }, + { HB_TAG('t', 'n', 'a', 'm'), "traditional_name_forms" }, + { HB_TAG('t', 'n', 'u', 'm'), "tabular_figures" }, + { HB_TAG('t', 'r', 'a', 'd'), "traditional_forms" }, + { HB_TAG('t', 'w', 'i', 'd'), "third_widths" }, + { HB_TAG('u', 'n', 'i', 'c'), "unicase" }, + { HB_TAG('v', 'a', 'l', 't'), "alternate_vertical_metrics" }, + { HB_TAG('v', 'a', 't', 'u'), "vattu_variants" }, + { HB_TAG('v', 'e', 'r', 't'), "vertical_writing" }, + { HB_TAG('v', 'h', 'a', 'l'), "alternate_vertical_half_metrics" }, + { HB_TAG('v', 'j', 'm', 'o'), "vowel_jamo_forms" }, + { HB_TAG('v', 'k', 'n', 'a'), "vertical_kana_alternates" }, + { HB_TAG('v', 'k', 'r', 'n'), "vertical_kerning" }, + { HB_TAG('v', 'p', 'a', 'l'), "proportional_alternate_vertical_metrics" }, + { HB_TAG('v', 'r', 't', '2'), "vertical_alternates_and_rotation" }, + { HB_TAG('v', 'r', 't', 'r'), "vertical_alternates_for_rotation" }, + { HB_TAG('z', 'e', 'r', 'o'), "slashed_zero" }, + // Registred OpenType variation tags. + { HB_TAG('i', 't', 'a', 'l'), "italic" }, + { HB_TAG('o', 'p', 's', 'z'), "optical_size" }, + { HB_TAG('s', 'l', 'n', 't'), "slant" }, + { HB_TAG('w', 'd', 't', 'h'), "width" }, + { HB_TAG('w', 'g', 'h', 't'), "weight" }, + { 0, String() }, +}; + +int32_t TextServerAdvanced::name_to_tag(const String &p_name) { + for (int i = 0; feature_set[i].tag != 0; i++) { + if (feature_set[i].name == p_name) { + return feature_set[i].tag; + } + } + + // No readable name, use tag string. + return hb_tag_from_string(p_name.replace("custom_", "").ascii().get_data(), -1); +} + +String TextServerAdvanced::tag_to_name(int32_t p_tag) { + for (int i = 0; feature_set[i].tag != 0; i++) { + if (feature_set[i].tag == p_tag) { + return feature_set[i].name; + } + } + + // No readable name, use tag string. + char name[5]; + memset(name, 0, 5); + hb_tag_to_string(p_tag, name); + return String("custom_") + String(name); +} + +/*************************************************************************/ +/* Font interface */ +/*************************************************************************/ + +RID TextServerAdvanced::create_font_system(const String &p_name, int p_base_size) { + ERR_FAIL_V_MSG(RID(), "System fonts are not supported by this text server."); +} + +RID TextServerAdvanced::create_font_resource(const String &p_filename, int p_base_size) { + _THREAD_SAFE_METHOD_ + FontDataAdvanced *fd = nullptr; + if (p_filename.get_extension() == "ttf" || p_filename.get_extension() == "otf" || p_filename.get_extension() == "woff") { + fd = memnew(DynamicFontDataAdvanced); + } else if (p_filename.get_extension() == "fnt" || p_filename.get_extension() == "font") { + fd = memnew(BitmapFontDataAdvanced); + } else { + return RID(); + } + + Error err = fd->load_from_file(p_filename, p_base_size); + if (err != OK) { + memdelete(fd); + return RID(); + } + + return font_owner.make_rid(fd); +} + +RID TextServerAdvanced::create_font_memory(const uint8_t *p_data, size_t p_size, const String &p_type, int p_base_size) { + _THREAD_SAFE_METHOD_ + FontDataAdvanced *fd = nullptr; + if (p_type == "ttf" || p_type == "otf" || p_type == "woff") { + fd = memnew(DynamicFontDataAdvanced); + } else if (p_type == "fnt" || p_type == "font") { + fd = memnew(BitmapFontDataAdvanced); + } else { + return RID(); + } + + Error err = fd->load_from_memory(p_data, p_size, p_base_size); + if (err != OK) { + memdelete(fd); + return RID(); + } + + return font_owner.make_rid(fd); +} + +float TextServerAdvanced::font_get_height(RID p_font, int p_size) const { + _THREAD_SAFE_METHOD_ + const FontDataAdvanced *fd = font_owner.getornull(p_font); + ERR_FAIL_COND_V(!fd, 0.f); + return fd->get_height(p_size); +} + +float TextServerAdvanced::font_get_ascent(RID p_font, int p_size) const { + _THREAD_SAFE_METHOD_ + const FontDataAdvanced *fd = font_owner.getornull(p_font); + ERR_FAIL_COND_V(!fd, 0.f); + return fd->get_ascent(p_size); +} + +float TextServerAdvanced::font_get_descent(RID p_font, int p_size) const { + _THREAD_SAFE_METHOD_ + const FontDataAdvanced *fd = font_owner.getornull(p_font); + ERR_FAIL_COND_V(!fd, 0.f); + return fd->get_descent(p_size); +} + +float TextServerAdvanced::font_get_underline_position(RID p_font, int p_size) const { + _THREAD_SAFE_METHOD_ + const FontDataAdvanced *fd = font_owner.getornull(p_font); + ERR_FAIL_COND_V(!fd, 0.f); + return fd->get_underline_position(p_size); +} + +float TextServerAdvanced::font_get_underline_thickness(RID p_font, int p_size) const { + _THREAD_SAFE_METHOD_ + const FontDataAdvanced *fd = font_owner.getornull(p_font); + ERR_FAIL_COND_V(!fd, 0.f); + return fd->get_underline_thickness(p_size); +} + +void TextServerAdvanced::font_set_antialiased(RID p_font, bool p_antialiased) { + _THREAD_SAFE_METHOD_ + FontDataAdvanced *fd = font_owner.getornull(p_font); + ERR_FAIL_COND(!fd); + fd->set_antialiased(p_antialiased); +} + +Dictionary TextServerAdvanced::font_get_feature_list(RID p_font) const { + _THREAD_SAFE_METHOD_ + const FontDataAdvanced *fd = font_owner.getornull(p_font); + ERR_FAIL_COND_V(!fd, Dictionary()); + return fd->get_feature_list(); +} + +bool TextServerAdvanced::font_get_antialiased(RID p_font) const { + _THREAD_SAFE_METHOD_ + const FontDataAdvanced *fd = font_owner.getornull(p_font); + ERR_FAIL_COND_V(!fd, false); + return fd->get_antialiased(); +} + +void TextServerAdvanced::font_set_distance_field_hint(RID p_font, bool p_distance_field) { + _THREAD_SAFE_METHOD_ + FontDataAdvanced *fd = font_owner.getornull(p_font); + ERR_FAIL_COND(!fd); + fd->set_distance_field_hint(p_distance_field); +} + +bool TextServerAdvanced::font_get_distance_field_hint(RID p_font) const { + _THREAD_SAFE_METHOD_ + const FontDataAdvanced *fd = font_owner.getornull(p_font); + ERR_FAIL_COND_V(!fd, false); + return fd->get_distance_field_hint(); +} + +void TextServerAdvanced::font_set_hinting(RID p_font, TextServer::Hinting p_hinting) { + _THREAD_SAFE_METHOD_ + FontDataAdvanced *fd = font_owner.getornull(p_font); + ERR_FAIL_COND(!fd); + fd->set_hinting(p_hinting); +} + +TextServer::Hinting TextServerAdvanced::font_get_hinting(RID p_font) const { + _THREAD_SAFE_METHOD_ + const FontDataAdvanced *fd = font_owner.getornull(p_font); + ERR_FAIL_COND_V(!fd, TextServer::HINTING_NONE); + return fd->get_hinting(); +} + +void TextServerAdvanced::font_set_force_autohinter(RID p_font, bool p_enabeld) { + _THREAD_SAFE_METHOD_ + FontDataAdvanced *fd = font_owner.getornull(p_font); + ERR_FAIL_COND(!fd); + fd->set_force_autohinter(p_enabeld); +} + +bool TextServerAdvanced::font_get_force_autohinter(RID p_font) const { + _THREAD_SAFE_METHOD_ + const FontDataAdvanced *fd = font_owner.getornull(p_font); + ERR_FAIL_COND_V(!fd, false); + return fd->get_force_autohinter(); +} + +bool TextServerAdvanced::font_has_char(RID p_font, char32_t p_char) const { + _THREAD_SAFE_METHOD_ + const FontDataAdvanced *fd = font_owner.getornull(p_font); + ERR_FAIL_COND_V(!fd, false); + return fd->has_char(p_char); +} + +String TextServerAdvanced::font_get_supported_chars(RID p_font) const { + _THREAD_SAFE_METHOD_ + const FontDataAdvanced *fd = font_owner.getornull(p_font); + ERR_FAIL_COND_V(!fd, String()); + return fd->get_supported_chars(); +} + +bool TextServerAdvanced::font_has_outline(RID p_font) const { + _THREAD_SAFE_METHOD_ + const FontDataAdvanced *fd = font_owner.getornull(p_font); + ERR_FAIL_COND_V(!fd, false); + return fd->has_outline(); +} + +float TextServerAdvanced::font_get_base_size(RID p_font) const { + _THREAD_SAFE_METHOD_ + const FontDataAdvanced *fd = font_owner.getornull(p_font); + ERR_FAIL_COND_V(!fd, 0.f); + return fd->get_base_size(); +} + +bool TextServerAdvanced::font_is_language_supported(RID p_font, const String &p_language) const { + _THREAD_SAFE_METHOD_ + const FontDataAdvanced *fd = font_owner.getornull(p_font); + ERR_FAIL_COND_V(!fd, false); + if (fd->lang_support_overrides.has(p_language)) { + return fd->lang_support_overrides[p_language]; + } else { + Vector tags = p_language.replace("-", "_").split("_"); + if (tags.size() > 0) { + if (fd->lang_support_overrides.has(tags[0])) { + return fd->lang_support_overrides[tags[0]]; + } + } + return fd->is_lang_supported(p_language); + } +} + +void TextServerAdvanced::font_set_language_support_override(RID p_font, const String &p_language, bool p_supported) { + _THREAD_SAFE_METHOD_ + FontDataAdvanced *fd = font_owner.getornull(p_font); + ERR_FAIL_COND(!fd); + fd->lang_support_overrides[p_language] = p_supported; +} + +bool TextServerAdvanced::font_get_language_support_override(RID p_font, const String &p_language) { + _THREAD_SAFE_METHOD_ + FontDataAdvanced *fd = font_owner.getornull(p_font); + ERR_FAIL_COND_V(!fd, false); + return fd->lang_support_overrides[p_language]; +} + +void TextServerAdvanced::font_remove_language_support_override(RID p_font, const String &p_language) { + _THREAD_SAFE_METHOD_ + FontDataAdvanced *fd = font_owner.getornull(p_font); + ERR_FAIL_COND(!fd); + fd->lang_support_overrides.erase(p_language); +} + +Vector TextServerAdvanced::font_get_language_support_overrides(RID p_font) { + _THREAD_SAFE_METHOD_ + FontDataAdvanced *fd = font_owner.getornull(p_font); + ERR_FAIL_COND_V(!fd, Vector()); + Vector ret; + for (Map::Element *E = fd->lang_support_overrides.front(); E; E = E->next()) { + ret.push_back(E->key()); + } + return ret; +} + +bool TextServerAdvanced::font_is_script_supported(RID p_font, const String &p_script) const { + _THREAD_SAFE_METHOD_ + const FontDataAdvanced *fd = font_owner.getornull(p_font); + ERR_FAIL_COND_V(!fd, false); + if (fd->script_support_overrides.has(p_script)) { + return fd->script_support_overrides[p_script]; + } else { + hb_script_t scr = hb_script_from_string(p_script.ascii().get_data(), -1); + return fd->is_script_supported(scr); + } +} + +void TextServerAdvanced::font_set_script_support_override(RID p_font, const String &p_script, bool p_supported) { + _THREAD_SAFE_METHOD_ + FontDataAdvanced *fd = font_owner.getornull(p_font); + ERR_FAIL_COND(!fd); + fd->script_support_overrides[p_script] = p_supported; +} + +bool TextServerAdvanced::font_get_script_support_override(RID p_font, const String &p_script) { + _THREAD_SAFE_METHOD_ + FontDataAdvanced *fd = font_owner.getornull(p_font); + ERR_FAIL_COND_V(!fd, false); + return fd->script_support_overrides[p_script]; +} + +void TextServerAdvanced::font_remove_script_support_override(RID p_font, const String &p_script) { + _THREAD_SAFE_METHOD_ + FontDataAdvanced *fd = font_owner.getornull(p_font); + ERR_FAIL_COND(!fd); + fd->script_support_overrides.erase(p_script); +} + +Vector TextServerAdvanced::font_get_script_support_overrides(RID p_font) { + _THREAD_SAFE_METHOD_ + FontDataAdvanced *fd = font_owner.getornull(p_font); + ERR_FAIL_COND_V(!fd, Vector()); + Vector ret; + for (Map::Element *E = fd->script_support_overrides.front(); E; E = E->next()) { + ret.push_back(E->key()); + } + return ret; +} + +uint32_t TextServerAdvanced::font_get_glyph_index(RID p_font, char32_t p_char, char32_t p_variation_selector) const { + _THREAD_SAFE_METHOD_ + const FontDataAdvanced *fd = font_owner.getornull(p_font); + ERR_FAIL_COND_V(!fd, 0); + return fd->get_glyph_index(p_char, p_variation_selector); +} + +Vector2 TextServerAdvanced::font_get_glyph_advance(RID p_font, uint32_t p_index, int p_size) const { + _THREAD_SAFE_METHOD_ + const FontDataAdvanced *fd = font_owner.getornull(p_font); + ERR_FAIL_COND_V(!fd, Vector2()); + return fd->get_advance(p_index, p_size); +} + +Vector2 TextServerAdvanced::font_get_glyph_kerning(RID p_font, uint32_t p_index_a, uint32_t p_index_b, int p_size) const { + _THREAD_SAFE_METHOD_ + const FontDataAdvanced *fd = font_owner.getornull(p_font); + ERR_FAIL_COND_V(!fd, Vector2()); + return fd->get_kerning(p_index_a, p_index_b, p_size); +} + +Vector2 TextServerAdvanced::font_draw_glyph(RID p_font, RID p_canvas, int p_size, const Vector2 &p_pos, uint32_t p_index, const Color &p_color) const { + _THREAD_SAFE_METHOD_ + const FontDataAdvanced *fd = font_owner.getornull(p_font); + ERR_FAIL_COND_V(!fd, Vector2()); + return fd->draw_glyph(p_canvas, p_size, p_pos, p_index, p_color); +} + +Vector2 TextServerAdvanced::font_draw_glyph_outline(RID p_font, RID p_canvas, int p_size, int p_outline_size, const Vector2 &p_pos, uint32_t p_index, const Color &p_color) const { + _THREAD_SAFE_METHOD_ + const FontDataAdvanced *fd = font_owner.getornull(p_font); + ERR_FAIL_COND_V(!fd, Vector2()); + return fd->draw_glyph_outline(p_canvas, p_size, p_outline_size, p_pos, p_index, p_color); +} + +float TextServerAdvanced::font_get_oversampling() const { + return oversampling; +} + +void TextServerAdvanced::font_set_oversampling(float p_oversampling) { + _THREAD_SAFE_METHOD_ + if (oversampling != p_oversampling) { + oversampling = p_oversampling; + List fonts; + font_owner.get_owned_list(&fonts); + for (List::Element *E = fonts.front(); E; E = E->next()) { + font_owner.getornull(E->get())->clear_cache(); + } + + List text_bufs; + shaped_owner.get_owned_list(&text_bufs); + for (List::Element *E = text_bufs.front(); E; E = E->next()) { + invalidate(shaped_owner.getornull(E->get())); + } + } +} + +Vector TextServerAdvanced::get_system_fonts() const { + return Vector(); +} + +/*************************************************************************/ +/* Shaped text buffer interface */ +/*************************************************************************/ + +int TextServerAdvanced::_convert_pos(const ShapedTextDataAdvanced *p_sd, int p_pos) const { + int32_t limit = p_pos; + if (p_sd->text.length() != p_sd->utf16.length()) { + const UChar *data = p_sd->utf16.ptr(); + for (int i = 0; i < p_pos; i++) { + if (U16_IS_LEAD(data[i])) { + limit--; + } + } + } + return limit; +} + +int TextServerAdvanced::_convert_pos_inv(const ShapedTextDataAdvanced *p_sd, int p_pos) const { + int32_t limit = p_pos; + if (p_sd->text.length() != p_sd->utf16.length()) { + for (int i = 0; i < p_pos; i++) { + if (p_sd->text[i] > 0xFFFF) { + limit++; + } + } + } + return limit; +} + +void TextServerAdvanced::invalidate(TextServerAdvanced::ShapedTextDataAdvanced *p_shaped) { + p_shaped->valid = false; + p_shaped->sort_valid = false; + p_shaped->line_breaks_valid = false; + p_shaped->justification_ops_valid = false; + p_shaped->ascent = 0.f; + p_shaped->descent = 0.f; + p_shaped->width = 0.f; + p_shaped->upos = 0.f; + p_shaped->uthk = 0.f; + p_shaped->glyphs.clear(); + p_shaped->glyphs_logical.clear(); + p_shaped->utf16 = Char16String(); + if (p_shaped->script_iter != nullptr) { + memdelete(p_shaped->script_iter); + p_shaped->script_iter = nullptr; + } + for (int i = 0; i < p_shaped->bidi_iter.size(); i++) { + ubidi_close(p_shaped->bidi_iter[i]); + } + p_shaped->bidi_iter.clear(); +} + +void TextServerAdvanced::full_copy(ShapedTextDataAdvanced *p_shaped) { + ShapedTextDataAdvanced *parent = shaped_owner.getornull(p_shaped->parent); + + for (Map::Element *E = parent->objects.front(); E; E = E->next()) { + if (E->get().pos >= p_shaped->start && E->get().pos < p_shaped->end) { + p_shaped->objects[E->key()] = E->get(); + } + } + + for (int k = 0; k < parent->spans.size(); k++) { + ShapedTextDataAdvanced::Span span = parent->spans[k]; + if (span.start >= p_shaped->end || span.end <= p_shaped->start) { + continue; + } + span.start = MAX(p_shaped->start, span.start); + span.end = MIN(p_shaped->end, span.end); + p_shaped->spans.push_back(span); + } + + p_shaped->parent = RID(); +} + +RID TextServerAdvanced::create_shaped_text(TextServer::Direction p_direction, TextServer::Orientation p_orientation) { + _THREAD_SAFE_METHOD_ + ShapedTextDataAdvanced *sd = memnew(ShapedTextDataAdvanced); + sd->hb_buffer = hb_buffer_create(); + sd->direction = p_direction; + sd->orientation = p_orientation; + return shaped_owner.make_rid(sd); +} + +void TextServerAdvanced::shaped_text_clear(RID p_shaped) { + _THREAD_SAFE_METHOD_ + ShapedTextDataAdvanced *sd = shaped_owner.getornull(p_shaped); + ERR_FAIL_COND(!sd); + + sd->parent = RID(); + sd->start = 0; + sd->end = 0; + sd->text = String(); + sd->spans.clear(); + sd->objects.clear(); + sd->bidi_override.clear(); + invalidate(sd); +} + +void TextServerAdvanced::shaped_text_set_direction(RID p_shaped, TextServer::Direction p_direction) { + _THREAD_SAFE_METHOD_ + ShapedTextDataAdvanced *sd = shaped_owner.getornull(p_shaped); + ERR_FAIL_COND(!sd); + + if (sd->direction != p_direction) { + if (sd->parent != RID()) { + full_copy(sd); + } + sd->direction = p_direction; + invalidate(sd); + } +} + +TextServer::Direction TextServerAdvanced::shaped_text_get_direction(RID p_shaped) const { + _THREAD_SAFE_METHOD_ + const ShapedTextDataAdvanced *sd = shaped_owner.getornull(p_shaped); + ERR_FAIL_COND_V(!sd, TextServer::DIRECTION_LTR); + return sd->direction; +} + +void TextServerAdvanced::shaped_text_set_bidi_override(RID p_shaped, const Vector &p_override) { + _THREAD_SAFE_METHOD_ + ShapedTextDataAdvanced *sd = shaped_owner.getornull(p_shaped); + ERR_FAIL_COND(!sd); + if (sd->parent != RID()) { + full_copy(sd); + } + sd->bidi_override = p_override; + invalidate(sd); +} + +void TextServerAdvanced::shaped_text_set_orientation(RID p_shaped, TextServer::Orientation p_orientation) { + _THREAD_SAFE_METHOD_ + ShapedTextDataAdvanced *sd = shaped_owner.getornull(p_shaped); + ERR_FAIL_COND(!sd); + if (sd->orientation != p_orientation) { + if (sd->parent != RID()) { + full_copy(sd); + } + sd->orientation = p_orientation; + invalidate(sd); + } +} + +void TextServerAdvanced::shaped_text_set_preserve_invalid(RID p_shaped, bool p_enabled) { + _THREAD_SAFE_METHOD_ + ShapedTextDataAdvanced *sd = shaped_owner.getornull(p_shaped); + ERR_FAIL_COND(!sd); + ERR_FAIL_COND(sd->parent != RID()); + if (sd->preserve_invalid != p_enabled) { + sd->preserve_invalid = p_enabled; + invalidate(sd); + } +} + +bool TextServerAdvanced::shaped_text_get_preserve_invalid(RID p_shaped) const { + _THREAD_SAFE_METHOD_ + const ShapedTextDataAdvanced *sd = shaped_owner.getornull(p_shaped); + ERR_FAIL_COND_V(!sd, false); + return sd->preserve_invalid; +} + +void TextServerAdvanced::shaped_text_set_preserve_control(RID p_shaped, bool p_enabled) { + _THREAD_SAFE_METHOD_ + ShapedTextDataAdvanced *sd = shaped_owner.getornull(p_shaped); + ERR_FAIL_COND(!sd); + if (sd->preserve_control != p_enabled) { + if (sd->parent != RID()) { + full_copy(sd); + } + sd->preserve_control = p_enabled; + invalidate(sd); + } +} + +bool TextServerAdvanced::shaped_text_get_preserve_control(RID p_shaped) const { + _THREAD_SAFE_METHOD_ + const ShapedTextDataAdvanced *sd = shaped_owner.getornull(p_shaped); + ERR_FAIL_COND_V(!sd, false); + return sd->preserve_control; +} + +TextServer::Orientation TextServerAdvanced::shaped_text_get_orientation(RID p_shaped) const { + _THREAD_SAFE_METHOD_ + const ShapedTextDataAdvanced *sd = shaped_owner.getornull(p_shaped); + ERR_FAIL_COND_V(!sd, TextServer::ORIENTATION_HORIZONTAL); + return sd->orientation; +} + +bool TextServerAdvanced::shaped_text_add_string(RID p_shaped, const String &p_text, const Vector &p_fonts, int p_size, const Dictionary &p_opentype_features, const String &p_language) { + _THREAD_SAFE_METHOD_ + ShapedTextDataAdvanced *sd = shaped_owner.getornull(p_shaped); + ERR_FAIL_COND_V(!sd, false); + ERR_FAIL_COND_V(p_size <= 0, false); + + if (p_text.empty()) { + return true; + } + + if (sd->parent != RID()) { + full_copy(sd); + } + + ShapedTextDataAdvanced::Span span; + span.start = sd->text.length(); + span.end = span.start + p_text.length(); + span.fonts = p_fonts; // Do not pre-sort, spans will be divided to subruns later. + span.font_size = p_size; + span.language = p_language; + span.features = p_opentype_features; + + sd->spans.push_back(span); + sd->text += p_text; + sd->end += p_text.length(); + invalidate(sd); + + return true; +} + +bool TextServerAdvanced::shaped_text_add_object(RID p_shaped, Variant p_key, const Size2 &p_size, VAlign p_inline_align, int p_length) { + _THREAD_SAFE_METHOD_ + ShapedTextDataAdvanced *sd = shaped_owner.getornull(p_shaped); + ERR_FAIL_COND_V(!sd, false); + ERR_FAIL_COND_V(p_key == Variant(), false); + ERR_FAIL_COND_V(sd->objects.has(p_key), false); + + if (sd->parent != RID()) { + full_copy(sd); + } + + ShapedTextDataAdvanced::Span span; + span.start = sd->text.length(); + span.end = span.start + p_length; + span.embedded_key = p_key; + + ShapedTextDataAdvanced::EmbeddedObject obj; + obj.inline_align = p_inline_align; + obj.rect.size = p_size; + obj.pos = span.start; + + sd->spans.push_back(span); + sd->text += String::chr(0xfffc).repeat(p_length); + sd->end += p_length; + sd->objects[p_key] = obj; + invalidate(sd); + + return true; +} + +bool TextServerAdvanced::shaped_text_resize_object(RID p_shaped, Variant p_key, const Size2 &p_size, VAlign p_inline_align) { + _THREAD_SAFE_METHOD_ + ShapedTextData *sd = shaped_owner.getornull(p_shaped); + ERR_FAIL_COND_V(!sd, false); + ERR_FAIL_COND_V(!sd->objects.has(p_key), false); + sd->objects[p_key].rect.size = p_size; + sd->objects[p_key].inline_align = p_inline_align; + if (sd->valid) { + // Recalc string metrics. + sd->ascent = 0; + sd->descent = 0; + sd->width = 0; + sd->upos = 0; + sd->uthk = 0; + for (int i = 0; i < sd->glyphs.size(); i++) { + Glyph gl = sd->glyphs[i]; + Variant key; + if (gl.count == 1) { + for (Map::Element *E = sd->objects.front(); E; E = E->next()) { + if (E->get().pos == gl.start) { + key = E->key(); + break; + } + } + } + if (key != Variant()) { + if (sd->orientation == ORIENTATION_HORIZONTAL) { + sd->objects[key].rect.position.x = sd->width; + sd->width += sd->objects[key].rect.size.x; + switch (sd->objects[key].inline_align) { + case VALIGN_TOP: { + sd->ascent = MAX(sd->ascent, sd->objects[key].rect.size.y); + } break; + case VALIGN_CENTER: { + sd->ascent = MAX(sd->ascent, sd->objects[key].rect.size.y / 2); + sd->descent = MAX(sd->descent, sd->objects[key].rect.size.y / 2); + } break; + case VALIGN_BOTTOM: { + sd->descent = MAX(sd->descent, sd->objects[key].rect.size.y); + } break; + } + sd->glyphs.write[i].advance = sd->objects[key].rect.size.x; + } else { + sd->objects[key].rect.position.y = sd->width; + sd->width += sd->objects[key].rect.size.y; + switch (sd->objects[key].inline_align) { + case VALIGN_TOP: { + sd->ascent = MAX(sd->ascent, sd->objects[key].rect.size.x); + } break; + case VALIGN_CENTER: { + sd->ascent = MAX(sd->ascent, sd->objects[key].rect.size.x / 2); + sd->descent = MAX(sd->descent, sd->objects[key].rect.size.x / 2); + } break; + case VALIGN_BOTTOM: { + sd->descent = MAX(sd->descent, sd->objects[key].rect.size.x); + } break; + } + sd->glyphs.write[i].advance = sd->objects[key].rect.size.y; + } + } else { + const FontDataAdvanced *fd = font_owner.getornull(gl.font_rid); + if (fd != nullptr) { + if (sd->orientation == ORIENTATION_HORIZONTAL) { + sd->ascent = MAX(sd->ascent, MAX(fd->get_ascent(gl.font_size), -gl.y_off)); + sd->descent = MAX(sd->descent, MAX(fd->get_descent(gl.font_size), gl.y_off)); + } else { + sd->ascent = MAX(sd->ascent, fd->get_advance(gl.index, gl.font_size).x * 0.5); + sd->descent = MAX(sd->descent, fd->get_advance(gl.index, gl.font_size).x * 0.5); + } + sd->upos = MAX(sd->upos, font_get_underline_position(gl.font_rid, gl.font_size)); + sd->uthk = MAX(sd->uthk, font_get_underline_thickness(gl.font_rid, gl.font_size)); + } else if (sd->preserve_invalid || (sd->preserve_control && is_control(gl.index))) { + // Glyph not found, replace with hex code box. + if (sd->orientation == ORIENTATION_HORIZONTAL) { + sd->ascent = MAX(sd->ascent, get_hex_code_box_size(gl.font_size, gl.index).y * 0.75f); + sd->descent = MAX(sd->descent, get_hex_code_box_size(gl.font_size, gl.index).y * 0.25f); + } else { + sd->ascent = MAX(sd->ascent, get_hex_code_box_size(gl.font_size, gl.index).x * 0.5f); + sd->descent = MAX(sd->descent, get_hex_code_box_size(gl.font_size, gl.index).x * 0.5f); + } + } + sd->width += gl.advance * gl.repeat; + } + } + + // Align embedded objects to baseline. + for (Map::Element *E = sd->objects.front(); E; E = E->next()) { + if ((E->get().pos >= sd->start) && (E->get().pos < sd->end)) { + if (sd->orientation == ORIENTATION_HORIZONTAL) { + switch (E->get().inline_align) { + case VALIGN_TOP: { + E->get().rect.position.y = -sd->ascent; + } break; + case VALIGN_CENTER: { + E->get().rect.position.y = -(E->get().rect.size.y / 2); + } break; + case VALIGN_BOTTOM: { + E->get().rect.position.y = sd->descent - E->get().rect.size.y; + } break; + } + } else { + switch (E->get().inline_align) { + case VALIGN_TOP: { + E->get().rect.position.x = -sd->ascent; + } break; + case VALIGN_CENTER: { + E->get().rect.position.x = -(E->get().rect.size.x / 2); + } break; + case VALIGN_BOTTOM: { + E->get().rect.position.x = sd->descent - E->get().rect.size.x; + } break; + } + } + } + } + } + return true; +} + +RID TextServerAdvanced::shaped_text_substr(RID p_shaped, int p_start, int p_length) const { + _THREAD_SAFE_METHOD_ + const ShapedTextDataAdvanced *sd = shaped_owner.getornull(p_shaped); + ERR_FAIL_COND_V(!sd, RID()); + if (sd->parent != RID()) { + return shaped_text_substr(sd->parent, p_start, p_length); + } + if (!sd->valid) { + const_cast(this)->shaped_text_shape(p_shaped); + } + ERR_FAIL_COND_V(p_start < 0 || p_length < 0, RID()); + ERR_FAIL_COND_V(sd->start > p_start || sd->end < p_start, RID()); + ERR_FAIL_COND_V(sd->end < p_start + p_length, RID()); + + ShapedTextDataAdvanced *new_sd = memnew(ShapedTextDataAdvanced); + + new_sd->hb_buffer = hb_buffer_create(); + new_sd->parent = p_shaped; + new_sd->start = p_start; + new_sd->end = p_start + p_length; + + new_sd->orientation = sd->orientation; + new_sd->direction = sd->direction; + new_sd->para_direction = sd->para_direction; + new_sd->line_breaks_valid = sd->line_breaks_valid; + new_sd->justification_ops_valid = sd->justification_ops_valid; + new_sd->sort_valid = false; + new_sd->upos = sd->upos; + new_sd->uthk = sd->uthk; + + if (p_length > 0) { + new_sd->text = sd->text.substr(p_start, p_length); + new_sd->utf16 = new_sd->text.utf16(); + new_sd->script_iter = memnew(ScriptIterator(new_sd->text, 0, new_sd->text.length())); + + for (int ov = 0; ov < sd->bidi_override.size(); ov++) { + UErrorCode err = U_ZERO_ERROR; + + if (sd->bidi_override[ov].x >= p_start + p_length || sd->bidi_override[ov].y <= p_start) { + continue; + } + int start = _convert_pos_inv(sd, MAX(0, p_start - sd->bidi_override[ov].x)); + int end = _convert_pos_inv(sd, MIN(p_start + p_length, sd->bidi_override[ov].y) - sd->bidi_override[ov].x); + + ERR_FAIL_COND_V_MSG((start < 0 || end - start > new_sd->utf16.length()), RID(), "Invalid BiDi override range."); + + //Create temporary line bidi & shape + UBiDi *bidi_iter = ubidi_openSized(end - start, 0, &err); + ERR_FAIL_COND_V_MSG(U_FAILURE(err), RID(), u_errorName(err)); + ubidi_setLine(sd->bidi_iter[ov], start, end, bidi_iter, &err); + if (U_FAILURE(err)) { + ubidi_close(bidi_iter); + ERR_FAIL_V_MSG(RID(), u_errorName(err)); + } + new_sd->bidi_iter.push_back(bidi_iter); + + err = U_ZERO_ERROR; + int bidi_run_count = ubidi_countRuns(bidi_iter, &err); + ERR_FAIL_COND_V_MSG(U_FAILURE(err), RID(), u_errorName(err)); + for (int i = 0; i < bidi_run_count; i++) { + int32_t _bidi_run_start = 0; + int32_t _bidi_run_length = 0; + ubidi_getVisualRun(bidi_iter, i, &_bidi_run_start, &_bidi_run_length); + + int32_t bidi_run_start = _convert_pos(sd, sd->bidi_override[ov].x + start + _bidi_run_start); + int32_t bidi_run_end = _convert_pos(sd, sd->bidi_override[ov].x + start + _bidi_run_start + _bidi_run_length); + + for (int j = 0; j < sd->glyphs.size(); j++) { + if ((sd->glyphs[j].start >= bidi_run_start) && (sd->glyphs[j].end <= bidi_run_end)) { + // Copy glyphs. + Glyph gl = sd->glyphs[j]; + Variant key; + if (gl.count == 1) { + for (Map::Element *E = sd->objects.front(); E; E = E->next()) { + if (E->get().pos == gl.start) { + key = E->key(); + new_sd->objects[key] = E->get(); + break; + } + } + } + if (key != Variant()) { + if (new_sd->orientation == ORIENTATION_HORIZONTAL) { + new_sd->objects[key].rect.position.x = new_sd->width; + new_sd->width += new_sd->objects[key].rect.size.x; + switch (new_sd->objects[key].inline_align) { + case VALIGN_TOP: { + new_sd->ascent = MAX(new_sd->ascent, new_sd->objects[key].rect.size.y); + } break; + case VALIGN_CENTER: { + new_sd->ascent = MAX(new_sd->ascent, new_sd->objects[key].rect.size.y / 2); + new_sd->descent = MAX(new_sd->descent, new_sd->objects[key].rect.size.y / 2); + } break; + case VALIGN_BOTTOM: { + new_sd->descent = MAX(new_sd->descent, new_sd->objects[key].rect.size.y); + } break; + } + } else { + new_sd->objects[key].rect.position.y = new_sd->width; + new_sd->width += new_sd->objects[key].rect.size.y; + switch (new_sd->objects[key].inline_align) { + case VALIGN_TOP: { + new_sd->ascent = MAX(new_sd->ascent, new_sd->objects[key].rect.size.x); + } break; + case VALIGN_CENTER: { + new_sd->ascent = MAX(new_sd->ascent, new_sd->objects[key].rect.size.x / 2); + new_sd->descent = MAX(new_sd->descent, new_sd->objects[key].rect.size.x / 2); + } break; + case VALIGN_BOTTOM: { + new_sd->descent = MAX(new_sd->descent, new_sd->objects[key].rect.size.x); + } break; + } + } + } else { + const FontDataAdvanced *fd = font_owner.getornull(gl.font_rid); + if (fd != nullptr) { + if (new_sd->orientation == ORIENTATION_HORIZONTAL) { + new_sd->ascent = MAX(new_sd->ascent, MAX(fd->get_ascent(gl.font_size), -gl.y_off)); + new_sd->descent = MAX(new_sd->descent, MAX(fd->get_descent(gl.font_size), gl.y_off)); + } else { + new_sd->ascent = MAX(new_sd->ascent, fd->get_advance(gl.index, gl.font_size).x * 0.5); + new_sd->descent = MAX(new_sd->descent, fd->get_advance(gl.index, gl.font_size).x * 0.5); + } + } else if (new_sd->preserve_invalid || (new_sd->preserve_control && is_control(gl.index))) { + // Glyph not found, replace with hex code box. + if (new_sd->orientation == ORIENTATION_HORIZONTAL) { + new_sd->ascent = MAX(new_sd->ascent, get_hex_code_box_size(gl.font_size, gl.index).y * 0.75f); + new_sd->descent = MAX(new_sd->descent, get_hex_code_box_size(gl.font_size, gl.index).y * 0.25f); + } else { + new_sd->ascent = MAX(new_sd->ascent, get_hex_code_box_size(gl.font_size, gl.index).x * 0.5f); + new_sd->descent = MAX(new_sd->descent, get_hex_code_box_size(gl.font_size, gl.index).x * 0.5f); + } + } + new_sd->width += gl.advance * gl.repeat; + } + new_sd->glyphs.push_back(gl); + } + } + } + } + + // Align embedded objects to baseline. + for (Map::Element *E = new_sd->objects.front(); E; E = E->next()) { + if ((E->get().pos >= new_sd->start) && (E->get().pos < new_sd->end)) { + if (sd->orientation == ORIENTATION_HORIZONTAL) { + switch (E->get().inline_align) { + case VALIGN_TOP: { + E->get().rect.position.y = -new_sd->ascent; + } break; + case VALIGN_CENTER: { + E->get().rect.position.y = -(E->get().rect.size.y / 2); + } break; + case VALIGN_BOTTOM: { + E->get().rect.position.y = new_sd->descent - E->get().rect.size.y; + } break; + } + } else { + switch (E->get().inline_align) { + case VALIGN_TOP: { + E->get().rect.position.x = -new_sd->ascent; + } break; + case VALIGN_CENTER: { + E->get().rect.position.x = -(E->get().rect.size.x / 2); + } break; + case VALIGN_BOTTOM: { + E->get().rect.position.x = new_sd->descent - E->get().rect.size.x; + } break; + } + } + } + } + } + + new_sd->valid = true; + + return shaped_owner.make_rid(new_sd); +} + +RID TextServerAdvanced::shaped_text_get_parent(RID p_shaped) const { + _THREAD_SAFE_METHOD_ + ShapedTextDataAdvanced *sd = shaped_owner.getornull(p_shaped); + ERR_FAIL_COND_V(!sd, RID()); + return sd->parent; +} + +float TextServerAdvanced::shaped_text_fit_to_width(RID p_shaped, float p_width, uint8_t /*JustificationFlag*/ p_jst_flags) { + _THREAD_SAFE_METHOD_ + ShapedTextDataAdvanced *sd = shaped_owner.getornull(p_shaped); + ERR_FAIL_COND_V(!sd, 0.f); + if (!sd->valid) { + const_cast(this)->shaped_text_shape(p_shaped); + } + if (!sd->justification_ops_valid) { + const_cast(this)->shaped_text_update_justification_ops(p_shaped); + } + + int start_pos = 0; + int end_pos = sd->glyphs.size() - 1; + + if ((p_jst_flags & JUSTIFICATION_AFTER_LAST_TAB) == JUSTIFICATION_AFTER_LAST_TAB) { + int start, end, delta; + if (sd->para_direction == DIRECTION_LTR) { + start = sd->glyphs.size() - 1; + end = -1; + delta = -1; + } else { + start = 0; + end = sd->glyphs.size(); + delta = +1; + } + + for (int i = start; i != end; i += delta) { + if ((sd->glyphs[i].flags & GRAPHEME_IS_TAB) == GRAPHEME_IS_TAB) { + if (sd->para_direction == DIRECTION_LTR) { + start_pos = i; + break; + } else { + end_pos = i; + break; + } + } + } + } + + if ((p_jst_flags & JUSTIFICATION_TRIM_EDGE_SPACES) == JUSTIFICATION_TRIM_EDGE_SPACES) { + while ((start_pos < end_pos) && ((sd->glyphs[start_pos].flags & GRAPHEME_IS_SPACE) == GRAPHEME_IS_SPACE || (sd->glyphs[start_pos].flags & GRAPHEME_IS_BREAK_HARD) == GRAPHEME_IS_BREAK_HARD || (sd->glyphs[start_pos].flags & GRAPHEME_IS_BREAK_SOFT) == GRAPHEME_IS_BREAK_SOFT)) { + sd->width -= sd->glyphs[start_pos].advance * sd->glyphs[start_pos].repeat; + sd->glyphs.write[start_pos].advance = 0; + start_pos += sd->glyphs[start_pos].count; + } + while ((start_pos < end_pos) && ((sd->glyphs[end_pos].flags & GRAPHEME_IS_SPACE) == GRAPHEME_IS_SPACE || (sd->glyphs[end_pos].flags & GRAPHEME_IS_BREAK_HARD) == GRAPHEME_IS_BREAK_HARD || (sd->glyphs[end_pos].flags & GRAPHEME_IS_BREAK_SOFT) == GRAPHEME_IS_BREAK_SOFT)) { + sd->width -= sd->glyphs[end_pos].advance * sd->glyphs[end_pos].repeat; + sd->glyphs.write[end_pos].advance = 0; + end_pos -= sd->glyphs[end_pos].count; + } + } + + int space_count = 0; + int elongation_count = 0; + for (int i = start_pos; i <= end_pos; i++) { + const Glyph &gl = sd->glyphs[i]; + if (gl.count > 0) { + if ((gl.flags & GRAPHEME_IS_ELONGATION) == GRAPHEME_IS_ELONGATION) { + elongation_count++; + } + if ((gl.flags & GRAPHEME_IS_SPACE) == GRAPHEME_IS_SPACE) { + space_count++; + } + } + } + + if ((elongation_count > 0) && ((p_jst_flags & JUSTIFICATION_KASHIDA) == JUSTIFICATION_KASHIDA)) { + float delta_width_per_kashida = (p_width - sd->width) / elongation_count; + for (int i = start_pos; i <= end_pos; i++) { + Glyph &gl = sd->glyphs.write[i]; + if (gl.count > 0) { + if (((gl.flags & GRAPHEME_IS_ELONGATION) == GRAPHEME_IS_ELONGATION) && (gl.advance > 0)) { + int count = delta_width_per_kashida / gl.advance; + int prev_count = gl.repeat; + if ((gl.flags & GRAPHEME_IS_VIRTUAL) == GRAPHEME_IS_VIRTUAL) { + gl.repeat = count; + } else { + gl.repeat = count + 1; + } + sd->width += (gl.repeat - prev_count) * gl.advance; + } + } + } + } + + if ((space_count > 0) && ((p_jst_flags & JUSTIFICATION_WORD_BOUND) == JUSTIFICATION_WORD_BOUND)) { + float delta_width_per_space = (p_width - sd->width) / space_count; + for (int i = start_pos; i <= end_pos; i++) { + Glyph &gl = sd->glyphs.write[i]; + if (gl.count > 0) { + if ((gl.flags & GRAPHEME_IS_SPACE) == GRAPHEME_IS_SPACE) { + float old_adv = gl.advance; + if ((gl.flags & GRAPHEME_IS_VIRTUAL) == GRAPHEME_IS_VIRTUAL) { + gl.advance = MAX(gl.advance + delta_width_per_space, 0.f); + } else { + gl.advance = MAX(gl.advance + delta_width_per_space, 0.05 * gl.font_size); + } + sd->width += (gl.advance - old_adv); + } + } + } + } + + return sd->width; +} + +float TextServerAdvanced::shaped_text_tab_align(RID p_shaped, const Vector &p_tab_stops) { + _THREAD_SAFE_METHOD_ + ShapedTextDataAdvanced *sd = shaped_owner.getornull(p_shaped); + ERR_FAIL_COND_V(!sd, 0.f); + if (!sd->valid) { + const_cast(this)->shaped_text_shape(p_shaped); + } + if (!sd->line_breaks_valid) { + const_cast(this)->shaped_text_update_breaks(p_shaped); + } + + int tab_index = 0; + float off = 0.f; + + int start, end, delta; + if (sd->para_direction == DIRECTION_LTR) { + start = 0; + end = sd->glyphs.size(); + delta = +1; + } else { + start = sd->glyphs.size() - 1; + end = -1; + delta = -1; + } + + for (int i = start; i != end; i += delta) { + if ((sd->glyphs[i].flags & GRAPHEME_IS_TAB) == GRAPHEME_IS_TAB) { + float tab_off = 0.f; + while (tab_off <= off) { + tab_off += p_tab_stops[tab_index]; + tab_index++; + if (tab_index >= p_tab_stops.size()) { + tab_index = 0; + } + } + float old_adv = sd->glyphs.write[i].advance; + sd->glyphs.write[i].advance = (tab_off - off); + sd->width += sd->glyphs.write[i].advance - old_adv; + off = 0; + continue; + } + off += sd->glyphs[i].advance * sd->glyphs[i].repeat; + } + + return 0.f; +} + +bool TextServerAdvanced::shaped_text_update_breaks(RID p_shaped) { + _THREAD_SAFE_METHOD_ + ShapedTextDataAdvanced *sd = shaped_owner.getornull(p_shaped); + ERR_FAIL_COND_V(!sd, false); + if (!sd->valid) { + shaped_text_shape(p_shaped); + } + + if (sd->line_breaks_valid) { + return true; // Noting to do. + } + + const UChar *data = sd->utf16.ptr(); + + Map breaks; + + UErrorCode err = U_ZERO_ERROR; + for (int i = 0; i < sd->spans.size(); i++) { + UBreakIterator *bi = ubrk_open(UBRK_LINE, sd->spans[i].language.ascii().get_data(), data + _convert_pos_inv(sd, sd->spans[i].start), _convert_pos_inv(sd, sd->spans[i].end - sd->spans[i].start), &err); + if (U_FAILURE(err)) { + //No data loaded - use fallback. + for (int j = sd->spans[i].start; j < sd->spans[i].end; j++) { + char32_t c = sd->text[j - sd->start]; + if (is_whitespace(c)) { + breaks[j] = false; + } + if (is_linebreak(c)) { + breaks[j] = true; + } + } + } else { + while (ubrk_next(bi) != UBRK_DONE) { + int pos = _convert_pos(sd, ubrk_current(bi)) + sd->spans[i].start - 1; + if (pos != sd->spans[i].end) { + if ((ubrk_getRuleStatus(bi) >= UBRK_LINE_HARD) && (ubrk_getRuleStatus(bi) < UBRK_LINE_HARD_LIMIT)) { + breaks[pos] = true; + } else if ((ubrk_getRuleStatus(bi) >= UBRK_LINE_SOFT) && (ubrk_getRuleStatus(bi) < UBRK_LINE_SOFT_LIMIT)) { + breaks[pos] = false; + } + } + } + } + ubrk_close(bi); + } + + sd->sort_valid = false; + sd->glyphs_logical.clear(); + + for (int i = 0; i < sd->glyphs.size(); i++) { + if (sd->glyphs[i].count > 0) { + char32_t c = sd->text[sd->glyphs[i].start - sd->start]; + if (c == 0xfffc) { + continue; + } + if (c == 0x0009 || c == 0x000b) { + sd->glyphs.write[i].flags |= GRAPHEME_IS_TAB; + } + if (breaks.has(sd->glyphs[i].start)) { + if (breaks[sd->glyphs[i].start]) { + sd->glyphs.write[i].flags |= GRAPHEME_IS_BREAK_HARD; + } else { + if (is_whitespace(c)) { + sd->glyphs.write[i].flags |= GRAPHEME_IS_BREAK_SOFT; + sd->glyphs.write[i].flags |= GRAPHEME_IS_SPACE; + } else { + TextServer::Glyph gl; + gl.start = sd->glyphs[i].start; + gl.end = sd->glyphs[i].end; + gl.count = 1; + gl.repeat = 1; + gl.font_rid = sd->glyphs[i].font_rid; + gl.font_size = sd->glyphs[i].font_size; + gl.flags = GRAPHEME_IS_BREAK_SOFT | GRAPHEME_IS_VIRTUAL; + sd->glyphs.insert(i + sd->glyphs[i].count, gl); // insert after + i += sd->glyphs[i].count; + continue; + } + } + } + + i += (sd->glyphs[i].count - 1); + } + } + + sd->line_breaks_valid = true; + + return sd->line_breaks_valid; +} + +_FORCE_INLINE_ int _generate_kashida_justification_opportunies(const String &p_data, int p_start, int p_end) { + int kashida_pos = -1; + int8_t priority = 100; + int i = p_start; + + char32_t pc = 0; + + while ((p_end > p_start) && is_transparent(p_data[p_end - 1])) { + p_end--; + } + + while (i < p_end) { + uint32_t c = p_data[i]; + + if (c == 0x0640) { + kashida_pos = i; + priority = 0; + } + if (priority >= 1 && i < p_end - 1) { + if (is_seen_sad(c) && (p_data[i + 1] != 0x200C)) { + kashida_pos = i; + priority = 1; + } + } + if (priority >= 2 && i > p_start) { + if (is_teh_marbuta(c) || is_dal(c) || (is_heh(c) && i == p_end - 1)) { + if (is_connected_to_prev(c, pc)) { + kashida_pos = i - 1; + priority = 2; + } + } + } + if (priority >= 3 && i > p_start) { + if (is_alef(c) || ((is_lam(c) || is_tah(c) || is_kaf(c) || is_gaf(c)) && i == p_end - 1)) { + if (is_connected_to_prev(c, pc)) { + kashida_pos = i - 1; + priority = 3; + } + } + } + if (priority >= 4 && i > p_start && i < p_end - 1) { + if (is_beh(c)) { + if (is_reh(p_data[i + 1]) || is_yeh(p_data[i + 1])) { + if (is_connected_to_prev(c, pc)) { + kashida_pos = i - 1; + priority = 4; + } + } + } + } + if (priority >= 5 && i > p_start) { + if (is_waw(c) || ((is_ain(c) || is_qaf(c) || is_feh(c)) && i == p_end - 1)) { + if (is_connected_to_prev(c, pc)) { + kashida_pos = i - 1; + priority = 5; + } + } + } + if (priority >= 6 && i > p_start) { + if (is_reh(c)) { + if (is_connected_to_prev(c, pc)) { + kashida_pos = i - 1; + priority = 6; + } + } + } + if (!is_transparent(c)) + pc = c; + i++; + } + + return kashida_pos; +} + +bool TextServerAdvanced::shaped_text_update_justification_ops(RID p_shaped) { + _THREAD_SAFE_METHOD_ + ShapedTextDataAdvanced *sd = shaped_owner.getornull(p_shaped); + ERR_FAIL_COND_V(!sd, false); + if (!sd->valid) { + shaped_text_shape(p_shaped); + } + if (!sd->line_breaks_valid) { + shaped_text_update_breaks(p_shaped); + } + + const UChar *data = sd->utf16.ptr(); + int32_t data_size = sd->utf16.length(); + + Map jstops; + + // Use ICU word iterator and custom kashida detection. + UErrorCode err = U_ZERO_ERROR; + UBreakIterator *bi = ubrk_open(UBRK_WORD, "", data, data_size, &err); + if (U_FAILURE(err)) { + // No data - use fallback + int limit = 0; + for (int i = 0; i < sd->text.length(); i++) { + if (is_whitespace(data[i])) { + int ks = _generate_kashida_justification_opportunies(sd->text, limit, i) + sd->start; + if (ks != -1) { + jstops[ks] = true; + } + limit = i + 1; + } + } + int ks = _generate_kashida_justification_opportunies(sd->text, limit, sd->text.length()) + sd->start; + if (ks != -1) { + jstops[ks] = true; + } + } else { + int limit = 0; + while (ubrk_next(bi) != UBRK_DONE) { + if (ubrk_getRuleStatus(bi) != UBRK_WORD_NONE) { + int i = _convert_pos(sd, ubrk_current(bi)); + jstops[i + sd->start] = false; + int ks = _generate_kashida_justification_opportunies(sd->text, limit, i) + sd->start; + if (ks != -1) { + jstops[ks] = true; + } + limit = i; + } + } + ubrk_close(bi); + } + + sd->sort_valid = false; + sd->glyphs_logical.clear(); + + if (jstops.size() > 0) { + for (int i = 0; i < sd->glyphs.size(); i++) { + if (sd->glyphs[i].count > 0) { + if (jstops.has(sd->glyphs[i].start)) { + char32_t c = sd->text[sd->glyphs[i].start - sd->start]; + if (c == 0xfffc) { + continue; + } + if (jstops[sd->glyphs[i].start]) { + if (c == 0x0640) { + sd->glyphs.write[i].flags |= GRAPHEME_IS_ELONGATION; + } else { + if (sd->glyphs[i].font_rid != RID()) { + TextServer::Glyph gl = _shape_single_glyph(sd, 0x0640, HB_SCRIPT_ARABIC, HB_DIRECTION_RTL, sd->glyphs[i].font_rid, sd->glyphs[i].font_size); + if ((gl.flags & GRAPHEME_IS_VALID) == GRAPHEME_IS_VALID) { + gl.start = sd->glyphs[i].start; + gl.end = sd->glyphs[i].end; + gl.repeat = 0; + gl.count = 1; + if (sd->orientation == ORIENTATION_HORIZONTAL) { + gl.y_off = sd->glyphs[i].y_off; + } else { + gl.x_off = sd->glyphs[i].x_off; + } + gl.flags |= GRAPHEME_IS_ELONGATION | GRAPHEME_IS_VIRTUAL; + sd->glyphs.insert(i, gl); + i++; + } + } + } + } else if (!is_whitespace(c)) { + TextServer::Glyph gl; + gl.start = sd->glyphs[i].start; + gl.end = sd->glyphs[i].end; + gl.count = 1; + gl.repeat = 1; + gl.font_rid = sd->glyphs[i].font_rid; + gl.font_size = sd->glyphs[i].font_size; + gl.flags = GRAPHEME_IS_SPACE | GRAPHEME_IS_VIRTUAL; + sd->glyphs.insert(i + sd->glyphs[i].count, gl); // insert after + i += sd->glyphs[i].count; + continue; + } + } + } + } + } + + sd->justification_ops_valid = true; + return sd->justification_ops_valid; +} + +TextServer::Glyph TextServerAdvanced::_shape_single_glyph(ShapedTextDataAdvanced *p_sd, char32_t p_char, hb_script_t p_script, hb_direction_t p_direction, RID p_font, int p_font_size) { + FontDataAdvanced *fd = font_owner.getornull(p_font); + hb_font_t *hb_font = fd->get_hb_handle(p_font_size); + + hb_buffer_clear_contents(p_sd->hb_buffer); + hb_buffer_set_direction(p_sd->hb_buffer, p_direction); + hb_buffer_set_flags(p_sd->hb_buffer, (hb_buffer_flags_t)(HB_BUFFER_FLAG_DEFAULT)); + hb_buffer_set_script(p_sd->hb_buffer, p_script); + hb_buffer_add_utf32(p_sd->hb_buffer, (const uint32_t *)&p_char, 1, 0, 1); + + hb_shape(hb_font, p_sd->hb_buffer, nullptr, 0); + + unsigned int glyph_count = 0; + hb_glyph_info_t *glyph_info = hb_buffer_get_glyph_infos(p_sd->hb_buffer, &glyph_count); + hb_glyph_position_t *glyph_pos = hb_buffer_get_glyph_positions(p_sd->hb_buffer, &glyph_count); + + // Process glyphs. + TextServer::Glyph gl; + gl.start = -1; + gl.end = -1; + + if (p_direction == HB_DIRECTION_RTL || p_direction == HB_DIRECTION_BTT) { + gl.flags |= TextServer::GRAPHEME_IS_RTL; + } + + gl.font_rid = p_font; + gl.font_size = p_font_size; + + if (glyph_count > 0) { + if (p_sd->orientation == ORIENTATION_HORIZONTAL) { + gl.advance = glyph_pos[0].x_advance / (64.0 / fd->get_font_scale(p_font_size)); + } else { + gl.advance = -glyph_pos[0].y_advance / (64.0 / fd->get_font_scale(p_font_size)); + } + gl.count = 1; + + gl.index = glyph_info[0].codepoint; + gl.x_off = glyph_pos[0].x_offset / (64.0 / fd->get_font_scale(p_font_size)); + gl.y_off = -glyph_pos[0].y_offset / (64.0 / fd->get_font_scale(p_font_size)); + + if ((glyph_info[0].codepoint != 0) || !u_isgraph(p_char)) { + gl.flags |= GRAPHEME_IS_VALID; + } + } + return gl; +} + +void TextServerAdvanced::_shape_run(ShapedTextDataAdvanced *p_sd, int32_t p_start, int32_t p_end, hb_script_t p_script, hb_direction_t p_direction, Vector p_fonts, int p_span, int p_fb_index) { + FontDataAdvanced *fd = nullptr; + if (p_fb_index < p_fonts.size()) { + fd = font_owner.getornull(p_fonts[p_fb_index]); + } + + if (fd == nullptr) { + // Add fallback glyohs + for (int i = p_start; i < p_end; i++) { + if (p_sd->preserve_invalid || (p_sd->preserve_control && is_control(p_sd->text[i]))) { + TextServer::Glyph gl; + gl.start = i; + gl.end = i + 1; + gl.count = 1; + gl.index = p_sd->text[i]; + gl.font_size = p_sd->spans[p_span].font_size; + gl.font_rid = RID(); + gl.flags = 0; + if (p_direction == HB_DIRECTION_RTL || p_direction == HB_DIRECTION_BTT) { + gl.flags |= TextServer::GRAPHEME_IS_RTL; + } + if (p_sd->orientation == ORIENTATION_HORIZONTAL) { + gl.advance = get_hex_code_box_size(gl.font_size, gl.index).x; + p_sd->ascent = MAX(p_sd->ascent, get_hex_code_box_size(gl.font_size, gl.index).y * 0.75f); + p_sd->descent = MAX(p_sd->descent, get_hex_code_box_size(gl.font_size, gl.index).y * 0.25f); + } else { + gl.advance = get_hex_code_box_size(gl.font_size, gl.index).y; + p_sd->ascent = MAX(p_sd->ascent, get_hex_code_box_size(gl.font_size, gl.index).x * 0.5f); + p_sd->descent = MAX(p_sd->descent, get_hex_code_box_size(gl.font_size, gl.index).x * 0.5f); + } + p_sd->width += gl.advance; + + p_sd->glyphs.push_back(gl); + } + } + return; + } + + hb_font_t *hb_font = fd->get_hb_handle(p_sd->spans[p_span].font_size); + ERR_FAIL_COND(hb_font == nullptr); + + hb_buffer_clear_contents(p_sd->hb_buffer); + hb_buffer_set_direction(p_sd->hb_buffer, p_direction); + if (p_sd->preserve_control) { + hb_buffer_set_flags(p_sd->hb_buffer, (hb_buffer_flags_t)(HB_BUFFER_FLAG_PRESERVE_DEFAULT_IGNORABLES | (p_start == 0 ? HB_BUFFER_FLAG_BOT : 0) | (p_end == p_sd->text.length() ? HB_BUFFER_FLAG_EOT : 0))); + } else { + hb_buffer_set_flags(p_sd->hb_buffer, (hb_buffer_flags_t)(HB_BUFFER_FLAG_DEFAULT | (p_start == 0 ? HB_BUFFER_FLAG_BOT : 0) | (p_end == p_sd->text.length() ? HB_BUFFER_FLAG_EOT : 0))); + } + hb_buffer_set_script(p_sd->hb_buffer, p_script); + + if (p_sd->spans[p_span].language != String()) { + hb_language_t lang = hb_language_from_string(p_sd->spans[p_span].language.ascii().get_data(), -1); + hb_buffer_set_language(p_sd->hb_buffer, lang); + } + + hb_buffer_add_utf32(p_sd->hb_buffer, (const uint32_t *)p_sd->text.ptr(), p_sd->text.length(), p_start, p_end - p_start); + + Vector ftrs; + for (const Variant *ftr = p_sd->spans[p_span].features.next(nullptr); ftr != nullptr; ftr = p_sd->spans[p_span].features.next(ftr)) { + double values = p_sd->spans[p_span].features[*ftr]; + if (values >= 0) { + hb_feature_t feature; + feature.tag = *ftr; + feature.value = values; + feature.start = 0; + feature.end = -1; + ftrs.push_back(feature); + } + } + hb_shape(hb_font, p_sd->hb_buffer, ftrs.empty() ? nullptr : &ftrs[0], ftrs.size()); + + unsigned int glyph_count = 0; + hb_glyph_info_t *glyph_info = hb_buffer_get_glyph_infos(p_sd->hb_buffer, &glyph_count); + hb_glyph_position_t *glyph_pos = hb_buffer_get_glyph_positions(p_sd->hb_buffer, &glyph_count); + + // Process glyphs. + if (glyph_count > 0) { + TextServer::Glyph *w = (TextServer::Glyph *)memalloc(glyph_count * sizeof(TextServer::Glyph)); + + int end = (p_direction == HB_DIRECTION_RTL || p_direction == HB_DIRECTION_BTT) ? p_end : 0; + uint32_t last_cluster_id = UINT32_MAX; + unsigned int last_cluster_index = 0; + bool last_cluster_valid = true; + + for (unsigned int i = 0; i < glyph_count; i++) { + if ((i > 0) && (last_cluster_id != glyph_info[i].cluster)) { + if (p_direction == HB_DIRECTION_RTL || p_direction == HB_DIRECTION_BTT) { + end = w[last_cluster_index].start; + } else { + for (unsigned int j = last_cluster_index; j < i; j++) { + w[j].end = glyph_info[i].cluster; + } + } + if (p_direction == HB_DIRECTION_RTL || p_direction == HB_DIRECTION_BTT) { + w[last_cluster_index].flags |= TextServer::GRAPHEME_IS_RTL; + } + if (last_cluster_valid) { + w[last_cluster_index].flags |= GRAPHEME_IS_VALID; + } + w[last_cluster_index].count = i - last_cluster_index; + last_cluster_index = i; + last_cluster_valid = true; + } + + last_cluster_id = glyph_info[i].cluster; + + TextServer::Glyph &gl = w[i]; + gl = TextServer::Glyph(); + + gl.start = glyph_info[i].cluster; + gl.end = end; + gl.count = 0; + + gl.font_rid = p_fonts[p_fb_index]; + gl.font_size = p_sd->spans[p_span].font_size; + + gl.index = glyph_info[i].codepoint; + if (gl.index != 0) { + if (p_sd->orientation == ORIENTATION_HORIZONTAL) { + gl.advance = glyph_pos[i].x_advance / (64.0 / fd->get_font_scale(gl.font_size)); + } else { + gl.advance = -glyph_pos[i].y_advance / (64.0 / fd->get_font_scale(gl.font_size)); + } + gl.x_off = glyph_pos[i].x_offset / (64.0 / fd->get_font_scale(gl.font_size)); + gl.y_off = -glyph_pos[i].y_offset / (64.0 / fd->get_font_scale(gl.font_size)); + } + + if (p_sd->preserve_control) { + last_cluster_valid = last_cluster_valid && ((glyph_info[i].codepoint != 0) || is_whitespace(p_sd->text[glyph_info[i].cluster]) || is_linebreak(p_sd->text[glyph_info[i].cluster])); + } else { + last_cluster_valid = last_cluster_valid && ((glyph_info[i].codepoint != 0) || !u_isgraph(p_sd->text[glyph_info[i].cluster])); + } + } + if (p_direction == HB_DIRECTION_LTR || p_direction == HB_DIRECTION_TTB) { + for (unsigned int j = last_cluster_index; j < glyph_count; j++) { + w[j].end = p_end; + } + } + w[last_cluster_index].count = glyph_count - last_cluster_index; + if (p_direction == HB_DIRECTION_RTL || p_direction == HB_DIRECTION_BTT) { + w[last_cluster_index].flags |= TextServer::GRAPHEME_IS_RTL; + } + if (last_cluster_valid) { + w[last_cluster_index].flags |= GRAPHEME_IS_VALID; + } + + //Fallback. + int failed_subrun_start = p_end + 1; + int failed_subrun_end = p_start; + + for (unsigned int i = 0; i < glyph_count; i++) { + if ((w[i].flags & GRAPHEME_IS_VALID) == GRAPHEME_IS_VALID) { + if (failed_subrun_start != p_end + 1) { + _shape_run(p_sd, failed_subrun_start, failed_subrun_end, p_script, p_direction, p_fonts, p_span, p_fb_index + 1); + failed_subrun_start = p_end + 1; + failed_subrun_end = p_start; + } + for (int j = 0; j < w[i].count; j++) { + if (p_sd->orientation == ORIENTATION_HORIZONTAL) { + p_sd->ascent = MAX(p_sd->ascent, MAX(fd->get_ascent(w[i + j].font_size), w[i + j].y_off)); + p_sd->descent = MAX(p_sd->descent, MAX(fd->get_descent(w[i + j].font_size), w[i + j].y_off)); + } else { + p_sd->ascent = MAX(p_sd->ascent, fd->get_advance(w[i + j].index, w[i + j].font_size).x * 0.5); + p_sd->descent = MAX(p_sd->descent, fd->get_advance(w[i + j].index, w[i + j].font_size).x * 0.5); + } + p_sd->upos = MAX(p_sd->upos, font_get_underline_position(w[i + j].font_rid, w[i + j].font_size)); + p_sd->uthk = MAX(p_sd->uthk, font_get_underline_thickness(w[i + j].font_rid, w[i + j].font_size)); + p_sd->width += w[i + j].advance; + p_sd->glyphs.push_back(w[i + j]); + } + } else { + if (failed_subrun_start >= w[i].start) { + failed_subrun_start = w[i].start; + } + if (failed_subrun_end <= w[i].end) { + failed_subrun_end = w[i].end; + } + } + i += w[i].count - 1; + } + memfree(w); + if (failed_subrun_start != p_end + 1) { + _shape_run(p_sd, failed_subrun_start, failed_subrun_end, p_script, p_direction, p_fonts, p_span, p_fb_index + 1); + } + } +} + +bool TextServerAdvanced::shaped_text_shape(RID p_shaped) { + _THREAD_SAFE_METHOD_ + ShapedTextDataAdvanced *sd = shaped_owner.getornull(p_shaped); + ERR_FAIL_COND_V(!sd, false); + + if (sd->valid) { + return true; + } + + if (sd->parent != RID()) { + full_copy(sd); + } + invalidate(sd); + + if (sd->text.length() == 0) { + sd->valid = true; + return true; + } + + sd->utf16 = sd->text.utf16(); + const UChar *data = sd->utf16.ptr(); + + // Create script iterator. + if (sd->script_iter == nullptr) { + sd->script_iter = memnew(ScriptIterator(sd->text, 0, sd->text.length())); + } + + if (sd->bidi_override.empty()) { + sd->bidi_override.push_back(Vector2i(0, sd->end)); + } + + for (int ov = 0; ov < sd->bidi_override.size(); ov++) { + // Create BiDi iterator. + int start = _convert_pos_inv(sd, sd->bidi_override[ov].x); + int end = _convert_pos_inv(sd, sd->bidi_override[ov].y); + + ERR_FAIL_COND_V_MSG((start < 0 || end - start > sd->utf16.length()), false, "Invalid BiDi override range."); + + UErrorCode err = U_ZERO_ERROR; + UBiDi *bidi_iter = ubidi_openSized(end, 0, &err); + ERR_FAIL_COND_V_MSG(U_FAILURE(err), false, u_errorName(err)); + + switch (sd->direction) { + case DIRECTION_LTR: { + ubidi_setPara(bidi_iter, data + start, end - start, UBIDI_LTR, nullptr, &err); + sd->para_direction = DIRECTION_LTR; + } break; + case DIRECTION_RTL: { + ubidi_setPara(bidi_iter, data + start, end - start, UBIDI_RTL, nullptr, &err); + sd->para_direction = DIRECTION_RTL; + } break; + case DIRECTION_AUTO: { + UBiDiDirection direction = ubidi_getBaseDirection(data + start, end - start); + if (direction != UBIDI_NEUTRAL) { + ubidi_setPara(bidi_iter, data + start, end - start, direction, nullptr, &err); + sd->para_direction = (direction == UBIDI_RTL) ? DIRECTION_RTL : DIRECTION_LTR; + } else { + ubidi_setPara(bidi_iter, data + start, end - start, UBIDI_DEFAULT_LTR, nullptr, &err); + sd->para_direction = DIRECTION_LTR; + } + } break; + } + ERR_FAIL_COND_V_MSG(U_FAILURE(err), false, u_errorName(err)); + sd->bidi_iter.push_back(bidi_iter); + + err = U_ZERO_ERROR; + int bidi_run_count = ubidi_countRuns(bidi_iter, &err); + ERR_FAIL_COND_V_MSG(U_FAILURE(err), false, u_errorName(err)); + for (int i = 0; i < bidi_run_count; i++) { + int32_t _bidi_run_start = 0; + int32_t _bidi_run_length = 0; + hb_direction_t bidi_run_direction = HB_DIRECTION_INVALID; + bool is_rtl = (ubidi_getVisualRun(bidi_iter, i, &_bidi_run_start, &_bidi_run_length) == UBIDI_LTR); + switch (sd->orientation) { + case ORIENTATION_HORIZONTAL: { + if (is_rtl) { + bidi_run_direction = HB_DIRECTION_LTR; + } else { + bidi_run_direction = HB_DIRECTION_RTL; + } + } break; + case ORIENTATION_VERTICAL: { + if (is_rtl) { + bidi_run_direction = HB_DIRECTION_TTB; + } else { + bidi_run_direction = HB_DIRECTION_BTT; + } + } + } + + int32_t bidi_run_start = _convert_pos(sd, sd->bidi_override[ov].x + _bidi_run_start); + int32_t bidi_run_end = _convert_pos(sd, sd->bidi_override[ov].x + _bidi_run_start + _bidi_run_length); + + // Shape runs. + + int scr_from = (is_rtl) ? 0 : sd->script_iter->script_ranges.size() - 1; + int scr_to = (is_rtl) ? sd->script_iter->script_ranges.size() : -1; + int scr_delta = (is_rtl) ? +1 : -1; + + for (int j = scr_from; j != scr_to; j += scr_delta) { + if ((sd->script_iter->script_ranges[j].start < bidi_run_end) && (sd->script_iter->script_ranges[j].end > bidi_run_start)) { + int32_t script_run_start = MAX(sd->script_iter->script_ranges[j].start, bidi_run_start); + int32_t script_run_end = MIN(sd->script_iter->script_ranges[j].end, bidi_run_end); + char scr_buffer[5] = { 0, 0, 0, 0, 0 }; + hb_tag_to_string(hb_script_to_iso15924_tag(sd->script_iter->script_ranges[j].script), scr_buffer); + String script = String(scr_buffer); + + int spn_from = (is_rtl) ? 0 : sd->spans.size() - 1; + int spn_to = (is_rtl) ? sd->spans.size() : -1; + int spn_delta = (is_rtl) ? +1 : -1; + + for (int k = spn_from; k != spn_to; k += spn_delta) { + const ShapedTextDataAdvanced::Span &span = sd->spans[k]; + if (span.start >= script_run_end || span.end <= script_run_start) { + continue; + } + if (span.embedded_key != Variant()) { + // Embedded object. + if (sd->orientation == ORIENTATION_HORIZONTAL) { + sd->objects[span.embedded_key].rect.position.x = sd->width; + sd->width += sd->objects[span.embedded_key].rect.size.x; + switch (sd->objects[span.embedded_key].inline_align) { + case VALIGN_TOP: { + sd->ascent = MAX(sd->ascent, sd->objects[span.embedded_key].rect.size.y); + } break; + case VALIGN_CENTER: { + sd->ascent = MAX(sd->ascent, sd->objects[span.embedded_key].rect.size.y / 2); + sd->descent = MAX(sd->descent, sd->objects[span.embedded_key].rect.size.y / 2); + } break; + case VALIGN_BOTTOM: { + sd->descent = MAX(sd->descent, sd->objects[span.embedded_key].rect.size.y); + } break; + } + } else { + sd->objects[span.embedded_key].rect.position.y = sd->width; + sd->width += sd->objects[span.embedded_key].rect.size.y; + switch (sd->objects[span.embedded_key].inline_align) { + case VALIGN_TOP: { + sd->ascent = MAX(sd->ascent, sd->objects[span.embedded_key].rect.size.x); + } break; + case VALIGN_CENTER: { + sd->ascent = MAX(sd->ascent, sd->objects[span.embedded_key].rect.size.x / 2); + sd->descent = MAX(sd->descent, sd->objects[span.embedded_key].rect.size.x / 2); + } break; + case VALIGN_BOTTOM: { + sd->descent = MAX(sd->descent, sd->objects[span.embedded_key].rect.size.x); + } break; + } + } + Glyph gl; + gl.start = span.start; + gl.end = span.end; + gl.count = 1; + gl.index = 0; + gl.flags = GRAPHEME_IS_VALID | GRAPHEME_IS_VIRTUAL; + if (sd->orientation == ORIENTATION_HORIZONTAL) { + gl.advance = sd->objects[span.embedded_key].rect.size.x; + } else { + gl.advance = sd->objects[span.embedded_key].rect.size.y; + } + sd->glyphs.push_back(gl); + } else { + Vector fonts; + // Push fonts with the language and script support first. + for (int l = 0; l < span.fonts.size(); l++) { + if ((font_is_language_supported(span.fonts[l], span.language)) && (font_is_script_supported(span.fonts[l], script))) { + fonts.push_back(sd->spans[k].fonts[l]); + } + } + // Push fonts with the script support. + for (int l = 0; l < sd->spans[k].fonts.size(); l++) { + if (!(font_is_language_supported(span.fonts[l], span.language)) && (font_is_script_supported(span.fonts[l], script))) { + fonts.push_back(sd->spans[k].fonts[l]); + } + } + // Push the rest valid fonts. + for (int l = 0; l < sd->spans[k].fonts.size(); l++) { + if (!(font_is_language_supported(span.fonts[l], span.language)) && !(font_is_script_supported(span.fonts[l], script))) { + fonts.push_back(sd->spans[k].fonts[l]); + } + } + _shape_run(sd, MAX(sd->spans[k].start, script_run_start), MIN(sd->spans[k].end, script_run_end), sd->script_iter->script_ranges[j].script, bidi_run_direction, fonts, k, 0); + } + } + } + } + } + } + + // Align embedded objects to baseline. + for (Map::Element *E = sd->objects.front(); E; E = E->next()) { + if (sd->orientation == ORIENTATION_HORIZONTAL) { + switch (E->get().inline_align) { + case VALIGN_TOP: { + E->get().rect.position.y = -sd->ascent; + } break; + case VALIGN_CENTER: { + E->get().rect.position.y = -(E->get().rect.size.y / 2); + } break; + case VALIGN_BOTTOM: { + E->get().rect.position.y = sd->descent - E->get().rect.size.y; + } break; + } + } else { + switch (E->get().inline_align) { + case VALIGN_TOP: { + E->get().rect.position.x = -sd->ascent; + } break; + case VALIGN_CENTER: { + E->get().rect.position.x = -(E->get().rect.size.x / 2); + } break; + case VALIGN_BOTTOM: { + E->get().rect.position.x = sd->descent - E->get().rect.size.x; + } break; + } + } + } + + sd->valid = true; + return sd->valid; +} + +bool TextServerAdvanced::shaped_text_is_ready(RID p_shaped) const { + _THREAD_SAFE_METHOD_ + const ShapedTextDataAdvanced *sd = shaped_owner.getornull(p_shaped); + ERR_FAIL_COND_V(!sd, false); + return sd->valid; +} + +Vector TextServerAdvanced::shaped_text_get_glyphs(RID p_shaped) const { + _THREAD_SAFE_METHOD_ + const ShapedTextDataAdvanced *sd = shaped_owner.getornull(p_shaped); + ERR_FAIL_COND_V(!sd, Vector()); + if (!sd->valid) { + const_cast(this)->shaped_text_shape(p_shaped); + } + return sd->glyphs; +} + +Vector2i TextServerAdvanced::shaped_text_get_range(RID p_shaped) const { + _THREAD_SAFE_METHOD_ + const ShapedTextDataAdvanced *sd = shaped_owner.getornull(p_shaped); + ERR_FAIL_COND_V(!sd, Vector2i()); + return Vector2(sd->start, sd->end); +} + +Vector TextServerAdvanced::shaped_text_sort_logical(RID p_shaped) { + _THREAD_SAFE_METHOD_ + ShapedTextDataAdvanced *sd = shaped_owner.getornull(p_shaped); + ERR_FAIL_COND_V(!sd, Vector()); + if (!sd->valid) { + const_cast(this)->shaped_text_shape(p_shaped); + } + + if (!sd->sort_valid) { + sd->glyphs_logical = sd->glyphs; + sd->glyphs_logical.sort_custom(); + sd->sort_valid = true; + } + + return sd->glyphs_logical; +} + +Array TextServerAdvanced::shaped_text_get_objects(RID p_shaped) const { + _THREAD_SAFE_METHOD_ + Array ret; + const ShapedTextDataAdvanced *sd = shaped_owner.getornull(p_shaped); + ERR_FAIL_COND_V(!sd, ret); + for (const Map::Element *E = sd->objects.front(); E; E = E->next()) { + ret.push_back(E->key()); + } + + return ret; +} + +Rect2 TextServerAdvanced::shaped_text_get_object_rect(RID p_shaped, Variant p_key) const { + _THREAD_SAFE_METHOD_ + const ShapedTextDataAdvanced *sd = shaped_owner.getornull(p_shaped); + ERR_FAIL_COND_V(!sd, Rect2()); + ERR_FAIL_COND_V(!sd->objects.has(p_key), Rect2()); + if (!sd->valid) { + const_cast(this)->shaped_text_shape(p_shaped); + } + return sd->objects[p_key].rect; +} + +Size2 TextServerAdvanced::shaped_text_get_size(RID p_shaped) const { + _THREAD_SAFE_METHOD_ + const ShapedTextDataAdvanced *sd = shaped_owner.getornull(p_shaped); + ERR_FAIL_COND_V(!sd, Size2()); + if (!sd->valid) { + const_cast(this)->shaped_text_shape(p_shaped); + } + if (sd->orientation == TextServer::ORIENTATION_HORIZONTAL) { + return Size2(sd->width, sd->ascent + sd->descent); + } else { + return Size2(sd->ascent + sd->descent, sd->width); + } +} + +float TextServerAdvanced::shaped_text_get_ascent(RID p_shaped) const { + _THREAD_SAFE_METHOD_ + const ShapedTextDataAdvanced *sd = shaped_owner.getornull(p_shaped); + ERR_FAIL_COND_V(!sd, 0.f); + if (!sd->valid) { + const_cast(this)->shaped_text_shape(p_shaped); + } + return sd->ascent; +} + +float TextServerAdvanced::shaped_text_get_descent(RID p_shaped) const { + _THREAD_SAFE_METHOD_ + const ShapedTextDataAdvanced *sd = shaped_owner.getornull(p_shaped); + ERR_FAIL_COND_V(!sd, 0.f); + if (!sd->valid) { + const_cast(this)->shaped_text_shape(p_shaped); + } + return sd->descent; +} + +float TextServerAdvanced::shaped_text_get_width(RID p_shaped) const { + _THREAD_SAFE_METHOD_ + const ShapedTextDataAdvanced *sd = shaped_owner.getornull(p_shaped); + ERR_FAIL_COND_V(!sd, 0.f); + if (!sd->valid) { + const_cast(this)->shaped_text_shape(p_shaped); + } + return sd->width; +} + +float TextServerAdvanced::shaped_text_get_underline_position(RID p_shaped) const { + _THREAD_SAFE_METHOD_ + const ShapedTextDataAdvanced *sd = shaped_owner.getornull(p_shaped); + ERR_FAIL_COND_V(!sd, 0.f); + if (!sd->valid) { + const_cast(this)->shaped_text_shape(p_shaped); + } + + return sd->upos; +} + +float TextServerAdvanced::shaped_text_get_underline_thickness(RID p_shaped) const { + _THREAD_SAFE_METHOD_ + const ShapedTextDataAdvanced *sd = shaped_owner.getornull(p_shaped); + ERR_FAIL_COND_V(!sd, 0.f); + if (!sd->valid) { + const_cast(this)->shaped_text_shape(p_shaped); + } + + return sd->uthk; +} + +struct num_system_data { + String lang; + String digits; + String percent_sign; + String exp; +}; + +static num_system_data num_systems[]{ + { "ar,ar_AR,ar_BH,ar_DJ,ar_EG,ar_ER,ar_IL,ar_IQ,ar_JO,ar_KM,ar_KW,ar_LB,ar_MR,ar_OM,ar_PS,ar_QA,ar_SA,ar_SD,ar_SO,ar_SS,ar_SY,ar_TD,ar_YE", U"٠١٢٣٤٥٦٧٨٩٫", U"٪", U"اس" }, + { "fa,ks,pa_Arab,ps,ug,ur_IN,ur,uz_Arab", U"۰۱۲۳۴۵۶۷۸۹٫", U"٪", U"اس" }, + { "as,bn,mni", U"০১২৩৪৫৬৭৮৯.", U"%", U"e" }, + { "mr,ne", U"०१२३४५६७८९.", U"%", U"e" }, + { "dz", U"༠༡༢༣༤༥༦༧༨༩.", U"%", U"e" }, + { "sat", U"᱐᱑᱒᱓᱔᱕᱖᱗᱘᱙.", U"%", U"e" }, + { "my", U"၀၁၂၃၄၅၆၇၈၉.", U"%", U"e" }, + { String(), String(), String(), String() }, +}; + +String TextServerAdvanced::format_number(const String &p_string, const String &p_language) const { + _THREAD_SAFE_METHOD_ + String lang = (p_language == "") ? TranslationServer::get_singleton()->get_tool_locale() : p_language; + + String res = p_string; + for (int i = 0; num_systems[i].lang != String(); i++) { + Vector langs = num_systems[i].lang.split(","); + if (langs.has(lang)) { + if (num_systems[i].digits == String()) { + return p_string; + } + res.replace("e", num_systems[i].exp); + res.replace("E", num_systems[i].exp); + char32_t *data = res.ptrw(); + for (int j = 0; j < res.size(); j++) { + if (data[j] >= 0x30 && data[j] <= 0x39) { + data[j] = num_systems[i].digits[data[j] - 0x30]; + } else if (data[j] == '.' || data[j] == ',') { + data[j] = num_systems[i].digits[10]; + } + } + break; + } + } + return res; +} + +String TextServerAdvanced::parse_number(const String &p_string, const String &p_language) const { + _THREAD_SAFE_METHOD_ + String lang = (p_language == "") ? TranslationServer::get_singleton()->get_tool_locale() : p_language; + + String res = p_string; + for (int i = 0; num_systems[i].lang != String(); i++) { + Vector langs = num_systems[i].lang.split(","); + if (langs.has(lang)) { + if (num_systems[i].digits == String()) { + return p_string; + } + res.replace(num_systems[i].exp, "e"); + char32_t *data = res.ptrw(); + for (int j = 0; j < res.size(); j++) { + if (data[j] == num_systems[i].digits[10]) { + data[j] = '.'; + } else { + for (int k = 0; k < 10; k++) { + if (data[j] == num_systems[i].digits[k]) { + data[j] = 0x30 + k; + } + } + } + } + break; + } + } + return res; +} + +String TextServerAdvanced::percent_sign(const String &p_language) const { + _THREAD_SAFE_METHOD_ + String lang = (p_language == "") ? TranslationServer::get_singleton()->get_tool_locale() : p_language; + + for (int i = 0; num_systems[i].lang != String(); i++) { + Vector langs = num_systems[i].lang.split(","); + if (langs.has(lang)) { + if (num_systems[i].percent_sign == String()) { + return "%"; + } + return num_systems[i].percent_sign; + } + } + return "%"; +} + +TextServer *TextServerAdvanced::create_func(Error &r_error, void *p_user_data) { + r_error = OK; + return memnew(TextServerAdvanced()); +} + +void TextServerAdvanced::register_server() { + TextServerManager::register_create_function(interface_name, interface_features, create_func, nullptr); +} + +TextServerAdvanced::TextServerAdvanced() { +} + +TextServerAdvanced::~TextServerAdvanced() { + u_cleanup(); +#ifndef ICU_STATIC_DATA + if (icu_data != nullptr) { + memfree(icu_data); + icu_data = nullptr; + } +#endif +} diff --git a/modules/text_server_adv/text_server_adv.h b/modules/text_server_adv/text_server_adv.h new file mode 100644 index 0000000000..f26b87f67e --- /dev/null +++ b/modules/text_server_adv/text_server_adv.h @@ -0,0 +1,244 @@ +/*************************************************************************/ +/* text_server_adv.h */ +/*************************************************************************/ +/* This file is part of: */ +/* GODOT ENGINE */ +/* https://godotengine.org */ +/*************************************************************************/ +/* Copyright (c) 2007-2020 Juan Linietsky, Ariel Manzur. */ +/* Copyright (c) 2014-2020 Godot Engine contributors (cf. AUTHORS.md). */ +/* */ +/* Permission is hereby granted, free of charge, to any person obtaining */ +/* a copy of this software and associated documentation files (the */ +/* "Software"), to deal in the Software without restriction, including */ +/* without limitation the rights to use, copy, modify, merge, publish, */ +/* distribute, sublicense, and/or sell copies of the Software, and to */ +/* permit persons to whom the Software is furnished to do so, subject to */ +/* the following conditions: */ +/* */ +/* The above copyright notice and this permission notice shall be */ +/* included in all copies or substantial portions of the Software. */ +/* */ +/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */ +/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */ +/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/ +/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */ +/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */ +/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */ +/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ +/*************************************************************************/ + +#ifndef TEXT_SERVER_ADV_H +#define TEXT_SERVER_ADV_H + +/*************************************************************************/ +/* ICU/HarfBuzz/Graphite backed Text Server implementation with BiDi, */ +/* shaping and advanced font features support. */ +/*************************************************************************/ + +#include "servers/text_server.h" + +#include "core/templates/rid_owner.h" +#include "scene/resources/texture.h" +#include "script_iterator.h" + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include + +#include "font_adv.h" + +class TextServerAdvanced : public TextServer { + GDCLASS(TextServerAdvanced, TextServer); + _THREAD_SAFE_CLASS_ + + static String interface_name; + static uint32_t interface_features; + + uint8_t *icu_data = nullptr; + + struct ShapedTextDataAdvanced : public ShapedTextData { + /* Intermediate data */ + Char16String utf16; + Vector bidi_iter; + Vector bidi_override; + ScriptIterator *script_iter = nullptr; + hb_buffer_t *hb_buffer = nullptr; + + ~ShapedTextDataAdvanced() { + for (int i = 0; i < bidi_iter.size(); i++) { + ubidi_close(bidi_iter[i]); + } + if (script_iter) { + memdelete(script_iter); + } + if (hb_buffer) { + hb_buffer_destroy(hb_buffer); + } + } + }; + + float oversampling = 1.f; + mutable RID_PtrOwner font_owner; + mutable RID_PtrOwner shaped_owner; + + int _convert_pos(const ShapedTextDataAdvanced *p_sd, int p_pos) const; + int _convert_pos_inv(const ShapedTextDataAdvanced *p_sd, int p_pos) const; + void _shape_run(ShapedTextDataAdvanced *p_sd, int32_t p_start, int32_t p_end, hb_script_t p_script, hb_direction_t p_direction, Vector p_fonts, int p_span, int p_fb_index); + TextServer::Glyph _shape_single_glyph(ShapedTextDataAdvanced *p_sd, char32_t p_char, hb_script_t p_script, hb_direction_t p_direction, RID p_font, int p_font_size); + +protected: + static void _bind_methods(){}; + + void full_copy(ShapedTextDataAdvanced *p_shaped); + void invalidate(ShapedTextDataAdvanced *p_shaped); + +public: + virtual bool has_feature(Feature p_feature) override; + virtual String get_name() const override; + + virtual void free(RID p_rid) override; + virtual bool has(RID p_rid) override; + virtual bool load_support_data(const String &p_filename) override; + +#ifdef TOOLS_ENABLED + virtual String get_support_data_filename() override { return _MKSTR(ICU_DATA_NAME); }; + virtual String get_support_data_info() override { return String("ICU break iteration data (") + _MKSTR(ICU_DATA_NAME) + String(")."); }; + virtual bool save_support_data(const String &p_filename) override; +#endif + + virtual bool is_locale_right_to_left(const String &p_locale) override; + + virtual int32_t name_to_tag(const String &p_name) override; + virtual String tag_to_name(int32_t p_tag) override; + + /* Font interface */ + virtual RID create_font_system(const String &p_name, int p_base_size = 16) override; + virtual RID create_font_resource(const String &p_filename, int p_base_size = 16) override; + virtual RID create_font_memory(const uint8_t *p_data, size_t p_size, const String &p_type, int p_base_size = 16) override; + + virtual float font_get_height(RID p_font, int p_size) const override; + virtual float font_get_ascent(RID p_font, int p_size) const override; + virtual float font_get_descent(RID p_font, int p_size) const override; + + virtual float font_get_underline_position(RID p_font, int p_size) const override; + virtual float font_get_underline_thickness(RID p_font, int p_size) const override; + + virtual void font_set_antialiased(RID p_font, bool p_antialiased) override; + virtual bool font_get_antialiased(RID p_font) const override; + + virtual Dictionary font_get_feature_list(RID p_font) const override; + + virtual void font_set_hinting(RID p_font, Hinting p_hinting) override; + virtual Hinting font_get_hinting(RID p_font) const override; + + virtual void font_set_distance_field_hint(RID p_font, bool p_distance_field) override; + virtual bool font_get_distance_field_hint(RID p_font) const override; + + virtual void font_set_force_autohinter(RID p_font, bool p_enabeld) override; + virtual bool font_get_force_autohinter(RID p_font) const override; + + virtual bool font_has_char(RID p_font, char32_t p_char) const override; + virtual String font_get_supported_chars(RID p_font) const override; + + virtual bool font_has_outline(RID p_font) const override; + virtual float font_get_base_size(RID p_font) const override; + + virtual bool font_is_language_supported(RID p_font, const String &p_language) const override; + virtual void font_set_language_support_override(RID p_font, const String &p_language, bool p_supported) override; + virtual bool font_get_language_support_override(RID p_font, const String &p_language) override; + virtual void font_remove_language_support_override(RID p_font, const String &p_language) override; + Vector font_get_language_support_overrides(RID p_font) override; + + virtual bool font_is_script_supported(RID p_font, const String &p_script) const override; + virtual void font_set_script_support_override(RID p_font, const String &p_script, bool p_supported) override; + virtual bool font_get_script_support_override(RID p_font, const String &p_script) override; + virtual void font_remove_script_support_override(RID p_font, const String &p_script) override; + Vector font_get_script_support_overrides(RID p_font) override; + + virtual uint32_t font_get_glyph_index(RID p_font, char32_t p_char, char32_t p_variation_selector = 0x0000) const override; + virtual Vector2 font_get_glyph_advance(RID p_font, uint32_t p_index, int p_size) const override; + virtual Vector2 font_get_glyph_kerning(RID p_font, uint32_t p_index_a, uint32_t p_index_b, int p_size) const override; + + virtual Vector2 font_draw_glyph(RID p_font, RID p_canvas, int p_size, const Vector2 &p_pos, uint32_t p_index, const Color &p_color = Color(1, 1, 1)) const override; + virtual Vector2 font_draw_glyph_outline(RID p_font, RID p_canvas, int p_size, int p_outline_size, const Vector2 &p_pos, uint32_t p_index, const Color &p_color = Color(1, 1, 1)) const override; + + virtual float font_get_oversampling() const override; + virtual void font_set_oversampling(float p_oversampling) override; + + virtual Vector get_system_fonts() const override; + + /* Shaped text buffer interface */ + + virtual RID create_shaped_text(Direction p_direction = DIRECTION_AUTO, Orientation p_orientation = ORIENTATION_HORIZONTAL) override; + + virtual void shaped_text_clear(RID p_shaped) override; + + virtual void shaped_text_set_direction(RID p_shaped, Direction p_direction = DIRECTION_AUTO) override; + virtual Direction shaped_text_get_direction(RID p_shaped) const override; + + virtual void shaped_text_set_bidi_override(RID p_shaped, const Vector &p_override) override; + + virtual void shaped_text_set_orientation(RID p_shaped, Orientation p_orientation = ORIENTATION_HORIZONTAL) override; + virtual Orientation shaped_text_get_orientation(RID p_shaped) const override; + + virtual void shaped_text_set_preserve_invalid(RID p_shaped, bool p_enabled) override; + virtual bool shaped_text_get_preserve_invalid(RID p_shaped) const override; + + virtual void shaped_text_set_preserve_control(RID p_shaped, bool p_enabled) override; + virtual bool shaped_text_get_preserve_control(RID p_shaped) const override; + + virtual bool shaped_text_add_string(RID p_shaped, const String &p_text, const Vector &p_fonts, int p_size, const Dictionary &p_opentype_features = Dictionary(), const String &p_language = "") override; + virtual bool shaped_text_add_object(RID p_shaped, Variant p_key, const Size2 &p_size, VAlign p_inline_align = VALIGN_CENTER, int p_length = 1) override; + virtual bool shaped_text_resize_object(RID p_shaped, Variant p_key, const Size2 &p_size, VAlign p_inline_align = VALIGN_CENTER) override; + + virtual RID shaped_text_substr(RID p_shaped, int p_start, int p_length) const override; + virtual RID shaped_text_get_parent(RID p_shaped) const override; + + virtual float shaped_text_fit_to_width(RID p_shaped, float p_width, uint8_t /*JustificationFlag*/ p_jst_flags = JUSTIFICATION_WORD_BOUND | JUSTIFICATION_KASHIDA) override; + virtual float shaped_text_tab_align(RID p_shaped, const Vector &p_tab_stops) override; + + virtual bool shaped_text_shape(RID p_shaped) override; + virtual bool shaped_text_update_breaks(RID p_shaped) override; + virtual bool shaped_text_update_justification_ops(RID p_shaped) override; + + virtual bool shaped_text_is_ready(RID p_shaped) const override; + + virtual Vector shaped_text_get_glyphs(RID p_shaped) const override; + + virtual Vector2i shaped_text_get_range(RID p_shaped) const override; + + virtual Vector shaped_text_sort_logical(RID p_shaped) override; + + virtual Array shaped_text_get_objects(RID p_shaped) const override; + virtual Rect2 shaped_text_get_object_rect(RID p_shaped, Variant p_key) const override; + + virtual Size2 shaped_text_get_size(RID p_shaped) const override; + virtual float shaped_text_get_ascent(RID p_shaped) const override; + virtual float shaped_text_get_descent(RID p_shaped) const override; + virtual float shaped_text_get_width(RID p_shaped) const override; + virtual float shaped_text_get_underline_position(RID p_shaped) const override; + virtual float shaped_text_get_underline_thickness(RID p_shaped) const override; + + virtual String format_number(const String &p_string, const String &p_language = "") const override; + virtual String parse_number(const String &p_string, const String &p_language = "") const override; + virtual String percent_sign(const String &p_language = "") const override; + + static TextServer *create_func(Error &r_error, void *p_user_data); + static void register_server(); + + TextServerAdvanced(); + ~TextServerAdvanced(); +}; + +#endif // TEXT_SERVER_ADV_H -- cgit v1.2.3