[Complex Text Layouts] Implement ICU / HarfBuzz based TextServer module.

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",

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<hb_bmp_font_t *>(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<hb_bmp_font_t *>(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<const hb_bmp_font_t *>(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<const hb_bmp_font_t *>(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<const hb_bmp_font_t *>(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<const hb_bmp_font_t *>(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<const hb_bmp_font_t *>(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<const hb_bmp_font_t *>(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<const hb_bmp_font_t *>(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<String, String> 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<Texture2D> 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> image = memnew(Image(data->img));
+		Ref<ImageTexture> 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<KerningPairKey, int>::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<float, hb_font_t *>::Element *E = cache.front(); E; E = E->next()) {
+		hb_font_destroy(E->get());
+	}
+}

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<Ref<Texture2D>> 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<uint32_t, Character> char_map;
+	Map<KerningPairKey, int> kerning_map;
+	Map<float, hb_font_t *> 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

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

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<String, Vector<uint8_t>> 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<CacheID, DataAtSize *>::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<uint8_t>();
+				Vector<uint8_t> &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<DynamicFontDataAdvanced *>(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<Image> 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<CacheID, DataAtSize *>::Element *E = size_cache.front(); E; E = E->next()) {
+		memdelete(E->get());
+	}
+	size_cache.clear();
+	for (Map<CacheID, DataAtSize *>::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<DynamicFontDataAdvanced *>(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<DynamicFontDataAdvanced *>(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<DynamicFontDataAdvanced *>(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<DynamicFontDataAdvanced *>(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<DynamicFontDataAdvanced *>(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<DynamicFontDataAdvanced *>(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<DynamicFontDataAdvanced *>(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<DynamicFontDataAdvanced *>(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<DynamicFontDataAdvanced *>(this)->get_data_for_size(base_size);
+	ERR_FAIL_COND_V(fds == nullptr, false);
+
+	const_cast<DynamicFontDataAdvanced *>(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<DynamicFontDataAdvanced *>(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<DynamicFontDataAdvanced *>(this)->get_data_for_size(p_size);
+	ERR_FAIL_COND_V(fds == nullptr, Vector2());
+
+	const_cast<DynamicFontDataAdvanced *>(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<DynamicFontDataAdvanced *>(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<DynamicFontDataAdvanced *>(this)->get_data_for_size(p_size);
+	ERR_FAIL_COND_V(fds == nullptr, Vector2());
+
+	const_cast<DynamicFontDataAdvanced *>(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<DynamicFontDataAdvanced *>(this)->get_data_for_size(p_size, p_outline_size);
+	ERR_FAIL_COND_V(fds == nullptr, Vector2());
+
+	const_cast<DynamicFontDataAdvanced *>(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);
+	}
+}

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 <ft2build.h>
+#include FT_FREETYPE_H
+#include FT_TRUETYPE_TABLES_H
+
+#include <hb-ft.h>
+#include <hb-ot.h>
+
+struct DynamicFontDataAdvanced : public FontDataAdvanced {
+	_THREAD_SAFE_CLASS_
+
+private:
+	struct CharTexture {
+		Vector<uint8_t> imgdata;
+		int texture_size = 0;
+		Vector<int> offsets;
+		Ref<ImageTexture> 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<CharTexture> textures;
+		HashMap<uint32_t, Character> 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<String, Vector<uint8_t>> 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<CacheID, DataAtSize *> size_cache;
+	Map<CacheID, DataAtSize *> 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

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 <hb.h>
+
+struct FontDataAdvanced {
+	Map<String, bool> lang_support_overrides;
+	Map<String, bool> 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

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() {
+}

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

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);
+}

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 <unicode/uchar.h>
+#include <unicode/uloc.h>
+#include <unicode/uscript.h>
+#include <unicode/ustring.h>
+#include <unicode/utypes.h>
+
+#include <hb-icu.h>
+#include <hb.h>
+
+class ScriptIterator {
+public:
+	struct ScriptRange {
+		int start;
+		int end;
+		hb_script_t script;
+	};
+	Vector<ScriptRange> 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

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<String> 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<String> 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<String>());
+	Vector<String> ret;
+	for (Map<String, bool>::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<String> 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<String>());
+	Vector<String> ret;
+	for (Map<String, bool>::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<RID> fonts;
+		font_owner.get_owned_list(&fonts);
+		for (List<RID>::Element *E = fonts.front(); E; E = E->next()) {
+			font_owner.getornull(E->get())->clear_cache();
+		}
+
+		List<RID> text_bufs;
+		shaped_owner.get_owned_list(&text_bufs);
+		for (List<RID>::Element *E = text_bufs.front(); E; E = E->next()) {
+			invalidate(shaped_owner.getornull(E->get()));
+		}
+	}
+}
+
+Vector<String> TextServerAdvanced::get_system_fonts() const {
+	return Vector<String>();
+}
+
+/*************************************************************************/
+/* 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<Variant, ShapedTextData::EmbeddedObject>::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<Vector2i> &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<RID> &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<Variant, ShapedTextData::EmbeddedObject>::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<Variant, ShapedTextData::EmbeddedObject>::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<TextServerAdvanced *>(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<Variant, ShapedTextData::EmbeddedObject>::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<Variant, ShapedTextData::EmbeddedObject>::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<TextServerAdvanced *>(this)->shaped_text_shape(p_shaped);
+	}
+	if (!sd->justification_ops_valid) {
+		const_cast<TextServerAdvanced *>(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<float> &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<TextServerAdvanced *>(this)->shaped_text_shape(p_shaped);
+	}
+	if (!sd->line_breaks_valid) {
+		const_cast<TextServerAdvanced *>(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<int, bool> 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<int, bool> 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<RID> 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<hb_feature_t> 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<RID> 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<Variant, ShapedTextData::EmbeddedObject>::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<TextServer::Glyph> 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<TextServer::Glyph>());
+	if (!sd->valid) {
+		const_cast<TextServerAdvanced *>(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<TextServer::Glyph> TextServerAdvanced::shaped_text_sort_logical(RID p_shaped) {
+	_THREAD_SAFE_METHOD_
+	ShapedTextDataAdvanced *sd = shaped_owner.getornull(p_shaped);
+	ERR_FAIL_COND_V(!sd, Vector<TextServer::Glyph>());
+	if (!sd->valid) {
+		const_cast<TextServerAdvanced *>(this)->shaped_text_shape(p_shaped);
+	}
+
+	if (!sd->sort_valid) {
+		sd->glyphs_logical = sd->glyphs;
+		sd->glyphs_logical.sort_custom<TextServer::GlyphCompare>();
+		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<Variant, ShapedTextData::EmbeddedObject>::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<TextServerAdvanced *>(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<TextServerAdvanced *>(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<TextServerAdvanced *>(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<TextServerAdvanced *>(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<TextServerAdvanced *>(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<TextServerAdvanced *>(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<TextServerAdvanced *>(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<String> 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<String> 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<String> 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
+}

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 <unicode/ubidi.h>
+#include <unicode/ubrk.h>
+#include <unicode/uchar.h>
+#include <unicode/uclean.h>
+#include <unicode/udata.h>
+#include <unicode/uiter.h>
+#include <unicode/uloc.h>
+#include <unicode/uscript.h>
+#include <unicode/ustring.h>
+#include <unicode/utypes.h>
+
+#include <hb-icu.h>
+#include <hb.h>
+
+#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<UBiDi *> bidi_iter;
+		Vector<Vector2i> 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<FontDataAdvanced> font_owner;
+	mutable RID_PtrOwner<ShapedTextDataAdvanced> 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<RID> 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<String> 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<String> 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<String> 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<Vector2i> &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<RID> &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<float> &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<Glyph> shaped_text_get_glyphs(RID p_shaped) const override;
+
+	virtual Vector2i shaped_text_get_range(RID p_shaped) const override;
+
+	virtual Vector<Glyph> 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