Makes FontData importable resource.

Adds multi-channel SDF font texture generation and rendering support.
Adds per-font oversampling support.
Adds FontData import plugins (for dynamic fonts, BMFonts and monospaced image fonts), font texture cache pre-generation and loading.
Adds BMFont binary format and outline support.

24 files changed, 5412 insertions, 4630 deletions

diff --git a/modules/gdnative/gdnative_api.json b/modules/gdnative/gdnative_api.json
index e02e275359..66d2dc267d 100644
--- a/modules/gdnative/gdnative_api.json
+++ b/modules/gdnative/gdnative_api.json
@@ -5354,7 +5354,7 @@
 				},
 				{
 					"name": "godot_glyph_get_advance",
-					"return_type": "godot_float",
+					"return_type": "godot_real_t",
 					"arguments": [
 						[
 							"const godot_glyph *",
@@ -5371,7 +5371,7 @@
 							"p_self"
 						],
 						[
-							"godot_float",
+							"godot_real_t",
 							"p_advance"
 						]
 					]
diff --git a/modules/gdnative/include/text/godot_text.h b/modules/gdnative/include/text/godot_text.h
index 6428f2f149..940cfd11f8 100644
--- a/modules/gdnative/include/text/godot_text.h
+++ b/modules/gdnative/include/text/godot_text.h
@@ -60,68 +60,109 @@ typedef struct {
 
 typedef struct {
 	godot_gdnative_api_version version;
+
 	void *(*constructor)(godot_object *);
 	void (*destructor)(void *);
+
 	godot_string (*get_name)(const void *);
 	godot_bool (*has_feature)(const void *, godot_int);
+
+	void (*free)(void *, godot_rid *);
+	bool (*has)(void *, godot_rid *);
+
 	bool (*load_support_data)(void *, const godot_string *);
 	godot_string (*get_support_data_filename)(const void *);
 	godot_string (*get_support_data_info)(const void *);
 	bool (*save_support_data)(void *, const godot_string *);
+
 	bool (*is_locale_right_to_left)(void *, const godot_string *);
-	void (*free)(void *, godot_rid *);
-	bool (*has)(void *, godot_rid *);
-	godot_rid (*create_font_system)(void *, const godot_string *, int);
-	godot_rid (*create_font_resource)(void *, const godot_string *, int);
-	godot_rid (*create_font_memory)(void *, const uint8_t *, size_t, godot_string *, int);
-	godot_rid (*create_font_bitmap)(void *, float, float, int);
-	void (*font_bitmap_add_texture)(void *, godot_rid *, const godot_object *);
-	void (*font_bitmap_add_char)(void *, godot_rid *, char32_t, int, const godot_rect2 *, const godot_vector2 *, float);
-	void (*font_bitmap_add_kerning_pair)(void *, godot_rid *, char32_t, char32_t, int);
-	float (*font_get_height)(void *, godot_rid *, int);
-	float (*font_get_ascent)(void *, godot_rid *, int);
-	float (*font_get_descent)(void *, godot_rid *, int);
-	float (*font_get_underline_position)(void *, godot_rid *, int);
-	float (*font_get_underline_thickness)(void *, godot_rid *, int);
-	int (*font_get_spacing_space)(void *, godot_rid *);
-	void (*font_set_spacing_space)(void *, godot_rid *, int);
-	int (*font_get_spacing_glyph)(void *, godot_rid *);
-	void (*font_set_spacing_glyph)(void *, godot_rid *, int);
+	int32_t (*name_to_tag)(const void *, const godot_string *);
+	godot_string (*tag_to_name)(const void *, int32_t);
+
+	godot_rid (*create_font)(void *);
+	void (*font_set_data)(void *, godot_rid *, const godot_packed_byte_array *);
+	void (*font_set_data_ptr)(void *, godot_rid *, const uint8_t *, size_t);
 	void (*font_set_antialiased)(void *, godot_rid *, bool);
-	bool (*font_get_antialiased)(void *, godot_rid *);
-	godot_dictionary (*font_get_feature_list)(void *, godot_rid *);
-	godot_dictionary (*font_get_variation_list)(void *, godot_rid *);
-	void (*font_set_variation)(void *, godot_rid *, const godot_string *, double);
-	double (*font_get_variation)(void *, godot_rid *, const godot_string *);
-	void (*font_set_distance_field_hint)(void *, godot_rid *, bool);
-	bool (*font_get_distance_field_hint)(void *, godot_rid *);
-	void (*font_set_hinting)(void *, godot_rid *, godot_int);
-	godot_int (*font_get_hinting)(void *, godot_rid *);
+	bool (*font_is_antialiased)(const void *, godot_rid *);
+	void (*font_set_multichannel_signed_distance_field)(void *, godot_rid *, bool);
+	bool (*font_is_multichannel_signed_distance_field)(const void *, godot_rid *);
+	void (*font_set_msdf_pixel_range)(void *, godot_rid *, godot_int);
+	godot_int (*font_get_msdf_pixel_range)(const void *, godot_rid *);
+	void (*font_set_msdf_size)(void *, godot_rid *, godot_int);
+	godot_int (*font_get_msdf_size)(const void *, godot_rid *);
+	void (*font_set_fixed_size)(void *, godot_rid *, godot_int);
+	godot_int (*font_get_fixed_size)(const void *, godot_rid *);
 	void (*font_set_force_autohinter)(void *, godot_rid *, bool);
-	bool (*font_get_force_autohinter)(void *, godot_rid *);
-	bool (*font_has_char)(void *, godot_rid *, char32_t);
-	godot_string (*font_get_supported_chars)(void *, godot_rid *);
-	bool (*font_has_outline)(void *, godot_rid *);
-	int (*font_get_base_size)(void *, godot_rid *);
-	bool (*font_is_language_supported)(void *, godot_rid *, const godot_string *);
+	bool (*font_is_force_autohinter)(const void *, godot_rid *);
+	void (*font_set_hinting)(void *, godot_rid *, godot_int);
+	godot_int (*font_get_hinting)(const void *, godot_rid *);
+	void (*font_set_variation_coordinates)(void *, godot_rid *, const godot_dictionary *);
+	godot_dictionary (*font_get_variation_coordinates)(const void *, godot_rid *);
+	void (*font_set_oversampling)(void *, godot_rid *, godot_real_t);
+	godot_real_t (*font_get_oversampling)(const void *, godot_rid *);
+	godot_array (*font_get_size_cache_list)(const void *, godot_rid *);
+	void (*font_clear_size_cache)(void *, godot_rid *);
+	void (*font_remove_size_cache)(void *, godot_rid *, const godot_vector2i *);
+	void (*font_set_ascent)(void *, godot_rid *, godot_int, godot_real_t);
+	godot_real_t (*font_get_ascent)(const void *, godot_rid *, godot_int);
+	void (*font_set_descent)(void *, godot_rid *, godot_int, godot_real_t);
+	godot_real_t (*font_get_descent)(const void *, godot_rid *, godot_int);
+	void (*font_set_underline_position)(void *, godot_rid *, godot_int, godot_real_t);
+	godot_real_t (*font_get_underline_position)(const void *, godot_rid *, godot_int);
+	void (*font_set_underline_thickness)(void *, godot_rid *, godot_int, godot_real_t);
+	godot_real_t (*font_get_underline_thickness)(const void *, godot_rid *, godot_int);
+	void (*font_set_scale)(void *, godot_rid *, godot_int, godot_real_t);
+	godot_real_t (*font_get_scale)(const void *, godot_rid *, godot_int);
+	void (*font_set_spacing)(void *, godot_rid *, godot_int, godot_int, godot_int);
+	godot_int (*font_get_spacing)(const void *, godot_rid *, godot_int, godot_int);
+	godot_int (*font_get_texture_count)(const void *, godot_rid *, const godot_vector2i *);
+	void (*font_clear_textures)(void *, godot_rid *, const godot_vector2i *);
+	void (*font_remove_texture)(void *, godot_rid *, const godot_vector2i *, godot_int);
+	void (*font_set_texture_image)(void *, godot_rid *, const godot_vector2i *, godot_int, const godot_object *);
+	godot_object *(*font_get_texture_image)(const void *, godot_rid *, const godot_vector2i *, godot_int);
+	void (*font_set_texture_offsets)(void *, godot_rid *, const godot_vector2i *, godot_int, const godot_packed_int32_array *);
+	godot_packed_int32_array (*font_get_texture_offsets)(const void *, godot_rid *, const godot_vector2i *, godot_int);
+	godot_array (*font_get_glyph_list)(const void *, godot_rid *, const godot_vector2i *);
+	void (*font_clear_glyphs)(void *, godot_rid *, const godot_vector2i *);
+	void (*font_remove_glyph)(void *, godot_rid *, const godot_vector2i *, int32_t);
+	godot_vector2 (*font_get_glyph_advance)(const void *, godot_rid *, godot_int, int32_t);
+	void (*font_set_glyph_advance)(void *, godot_rid *, godot_int, int32_t, const godot_vector2 *);
+	godot_vector2 (*font_get_glyph_offset)(const void *, godot_rid *, const godot_vector2i *, int32_t);
+	void (*font_set_glyph_offset)(void *, godot_rid *, const godot_vector2i *, int32_t, const godot_vector2 *);
+	godot_vector2 (*font_get_glyph_size)(const void *, godot_rid *, const godot_vector2i *, int32_t);
+	void (*font_set_glyph_size)(void *, godot_rid *, const godot_vector2i *, int32_t, const godot_vector2 *);
+	godot_rect2 (*font_get_glyph_uv_rect)(const void *, godot_rid *, const godot_vector2i *, int32_t);
+	void (*font_set_glyph_uv_rect)(void *, godot_rid *, const godot_vector2i *, int32_t, const godot_rect2 *);
+	godot_int (*font_get_glyph_texture_idx)(const void *, godot_rid *, const godot_vector2i *, int32_t);
+	void (*font_set_glyph_texture_idx)(void *, godot_rid *, const godot_vector2i *, int32_t, godot_int);
+	bool (*font_get_glyph_contours)(const void *, godot_rid *, godot_int, int32_t, godot_packed_vector3_array *, godot_packed_int32_array *, bool *);
+	godot_array (*font_get_kerning_list)(const void *, godot_rid *, godot_int);
+	void (*font_clear_kerning_map)(void *, godot_rid *, godot_int);
+	void (*font_remove_kerning)(void *, godot_rid *, godot_int, const godot_vector2i *);
+	void (*font_set_kerning)(void *, godot_rid *, godot_int, const godot_vector2i *, const godot_vector2 *);
+	godot_vector2 (*font_get_kerning)(const void *, godot_rid *, godot_int, const godot_vector2i *);
+	int32_t (*font_get_glyph_index)(const void *, godot_rid *, godot_int, char32_t, char32_t);
+	bool (*font_has_char)(const void *, godot_rid *, char32_t);
+	godot_string (*font_get_supported_chars)(const void *, godot_rid *);
+	void (*font_render_range)(void *, godot_rid *, const godot_vector2i *, char32_t, char32_t);
+	void (*font_render_glyph)(void *, godot_rid *, const godot_vector2i *, int32_t);
+	void (*font_draw_glyph)(const void *, godot_rid *, godot_rid *, godot_int, const godot_vector2 *, int32_t, const godot_color *);
+	void (*font_draw_glyph_outline)(const void *, godot_rid *, godot_rid *, godot_int, godot_int, const godot_vector2 *, int32_t, const godot_color *);
+	bool (*font_is_language_supported)(const void *, godot_rid *, const godot_string *);
 	void (*font_set_language_support_override)(void *, godot_rid *, const godot_string *, bool);
-	bool (*font_get_language_support_override)(void *, godot_rid *, const godot_string *);
+	bool (*font_get_language_support_override)(const void *, godot_rid *, const godot_string *);
 	void (*font_remove_language_support_override)(void *, godot_rid *, const godot_string *);
-	godot_packed_string_array (*font_get_language_support_overrides)(void *, godot_rid *);
-	bool (*font_is_script_supported)(void *, godot_rid *, const godot_string *);
+	godot_packed_string_array (*font_get_language_support_overrides)(const void *, godot_rid *);
+	bool (*font_is_script_supported)(const void *, godot_rid *, const godot_string *);
 	void (*font_set_script_support_override)(void *, godot_rid *, const godot_string *, bool);
-	bool (*font_get_script_support_override)(void *, godot_rid *, const godot_string *);
+	bool (*font_get_script_support_override)(const void *, godot_rid *, const godot_string *);
 	void (*font_remove_script_support_override)(void *, godot_rid *, const godot_string *);
-	godot_packed_string_array (*font_get_script_support_overrides)(void *, godot_rid *);
-	uint32_t (*font_get_glyph_index)(void *, godot_rid *, char32_t, char32_t);
-	godot_vector2 (*font_get_glyph_advance)(void *, godot_rid *, uint32_t, int);
-	godot_vector2 (*font_get_glyph_kerning)(void *, godot_rid *, uint32_t, uint32_t, int);
-	godot_vector2 (*font_draw_glyph)(void *, godot_rid *, godot_rid *, int, const godot_vector2 *, uint32_t, const godot_color *);
-	godot_vector2 (*font_draw_glyph_outline)(void *, godot_rid *, godot_rid *, int, int, const godot_vector2 *, uint32_t, const godot_color *);
-	bool (*font_get_glyph_contours)(void *, godot_rid *, int, uint32_t, godot_packed_vector3_array *, godot_packed_int32_array *, bool *);
-	float (*font_get_oversampling)(void *);
-	void (*font_set_oversampling)(void *, float);
-	godot_packed_string_array (*get_system_fonts)(void *);
+	godot_packed_string_array (*font_get_script_support_overrides)(const void *, godot_rid *);
+	godot_dictionary (*font_supported_feature_list)(const void *, godot_rid *);
+	godot_dictionary (*font_supported_variation_list)(const void *, godot_rid *);
+	godot_real_t (*font_get_global_oversampling)(const void *);
+	void (*font_set_global_oversampling)(void *, godot_real_t);
+
 	godot_rid (*create_shaped_text)(void *, godot_int, godot_int);
 	void (*shaped_text_clear)(void *, godot_rid *);
 	void (*shaped_text_set_direction)(void *, godot_rid *, godot_int);
@@ -138,27 +179,28 @@ typedef struct {
 	bool (*shaped_text_resize_object)(void *, godot_rid *, const godot_variant *, const godot_vector2 *, godot_int);
 	godot_rid (*shaped_text_substr)(void *, godot_rid *, godot_int, godot_int);
 	godot_rid (*shaped_text_get_parent)(void *, godot_rid *);
-	float (*shaped_text_fit_to_width)(void *, godot_rid *, float, uint8_t);
-	float (*shaped_text_tab_align)(void *, godot_rid *, godot_packed_float32_array *);
+	godot_real_t (*shaped_text_fit_to_width)(void *, godot_rid *, godot_real_t, uint8_t);
+	godot_real_t (*shaped_text_tab_align)(void *, godot_rid *, godot_packed_float32_array *);
 	bool (*shaped_text_shape)(void *, godot_rid *);
 	bool (*shaped_text_update_breaks)(void *, godot_rid *);
 	bool (*shaped_text_update_justification_ops)(void *, godot_rid *);
-	void (*shaped_text_overrun_trim_to_width)(void *, godot_rid *, float, uint8_t);
+	void (*shaped_text_overrun_trim_to_width)(void *, godot_rid *, godot_real_t, uint8_t);
 	bool (*shaped_text_is_ready)(void *, godot_rid *);
 	godot_packed_glyph_array (*shaped_text_get_glyphs)(void *, godot_rid *);
 	godot_vector2i (*shaped_text_get_range)(void *, godot_rid *);
 	godot_packed_glyph_array (*shaped_text_sort_logical)(void *, godot_rid *);
 	godot_packed_vector2i_array (*shaped_text_get_line_breaks_adv)(void *, godot_rid *, godot_packed_float32_array *, int, bool, uint8_t);
-	godot_packed_vector2i_array (*shaped_text_get_line_breaks)(void *, godot_rid *, float, int, uint8_t);
+	godot_packed_vector2i_array (*shaped_text_get_line_breaks)(void *, godot_rid *, godot_real_t, int, uint8_t);
 	godot_packed_vector2i_array (*shaped_text_get_word_breaks)(void *, godot_rid *, int);
 	godot_array (*shaped_text_get_objects)(void *, godot_rid *);
 	godot_rect2 (*shaped_text_get_object_rect)(void *, godot_rid *, const godot_variant *);
 	godot_vector2 (*shaped_text_get_size)(void *, godot_rid *);
-	float (*shaped_text_get_ascent)(void *, godot_rid *);
-	float (*shaped_text_get_descent)(void *, godot_rid *);
-	float (*shaped_text_get_width)(void *, godot_rid *);
-	float (*shaped_text_get_underline_position)(void *, godot_rid *);
-	float (*shaped_text_get_underline_thickness)(void *, godot_rid *);
+	godot_real_t (*shaped_text_get_ascent)(void *, godot_rid *);
+	godot_real_t (*shaped_text_get_descent)(void *, godot_rid *);
+	godot_real_t (*shaped_text_get_width)(void *, godot_rid *);
+	godot_real_t (*shaped_text_get_underline_position)(void *, godot_rid *);
+	godot_real_t (*shaped_text_get_underline_thickness)(void *, godot_rid *);
+
 	godot_string (*format_number)(void *, const godot_string *, const godot_string *);
 	godot_string (*parse_number)(void *, const godot_string *, const godot_string *);
 	godot_string (*percent_sign)(void *, const godot_string *);
@@ -185,8 +227,8 @@ void GDAPI godot_glyph_set_flags(godot_glyph *p_self, godot_int p_flags);
 godot_vector2 GDAPI godot_glyph_get_offset(const godot_glyph *p_self);
 void GDAPI godot_glyph_set_offset(godot_glyph *p_self, const godot_vector2 *p_offset);
 
-godot_float GDAPI godot_glyph_get_advance(const godot_glyph *p_self);
-void GDAPI godot_glyph_set_advance(godot_glyph *p_self, godot_float p_advance);
+godot_real_t GDAPI godot_glyph_get_advance(const godot_glyph *p_self);
+void GDAPI godot_glyph_set_advance(godot_glyph *p_self, godot_real_t p_advance);
 
 godot_rid GDAPI godot_glyph_get_font(const godot_glyph *p_self);
 void GDAPI godot_glyph_set_font(godot_glyph *p_self, godot_rid *p_font);
diff --git a/modules/gdnative/text/text_server_gdnative.cpp b/modules/gdnative/text/text_server_gdnative.cpp
index 3ed3f5449e..195c32c3f8 100644
--- a/modules/gdnative/text/text_server_gdnative.cpp
+++ b/modules/gdnative/text/text_server_gdnative.cpp
@@ -88,299 +88,479 @@ bool TextServerGDNative::is_locale_right_to_left(const String &p_locale) {
 	return interface->is_locale_right_to_left(data, (godot_string *)&p_locale);
 }
 
+int32_t TextServerGDNative::name_to_tag(const String &p_name) const {
+	ERR_FAIL_COND_V(interface == nullptr, 0);
+	return interface->name_to_tag(data, (godot_string *)&p_name);
+}
+
+String TextServerGDNative::tag_to_name(int32_t p_tag) const {
+	ERR_FAIL_COND_V(interface == nullptr, String());
+	godot_string result = interface->tag_to_name(data, p_tag);
+	String name = *(String *)&result;
+	godot_string_destroy(&result);
+	return name;
+}
+
 /*************************************************************************/
-/* Font interface */
+/* Font                                                                  */
 /*************************************************************************/
 
-RID TextServerGDNative::create_font_system(const String &p_name, int p_base_size) {
+RID TextServerGDNative::create_font() {
 	ERR_FAIL_COND_V(interface == nullptr, RID());
-	godot_rid result = interface->create_font_system(data, (const godot_string *)&p_name, p_base_size);
+	godot_rid result = interface->create_font(data);
 	RID rid = *(RID *)&result;
 	return rid;
 }
 
-RID TextServerGDNative::create_font_resource(const String &p_filename, int p_base_size) {
-	ERR_FAIL_COND_V(interface == nullptr, RID());
-	godot_rid result = interface->create_font_resource(data, (const godot_string *)&p_filename, p_base_size);
-	RID rid = *(RID *)&result;
-	return rid;
+void TextServerGDNative::font_set_data(RID p_font_rid, const PackedByteArray &p_data) {
+	ERR_FAIL_COND(interface == nullptr);
+	interface->font_set_data(data, (godot_rid *)&p_font_rid, (const godot_packed_byte_array *)&p_data);
 }
 
-RID TextServerGDNative::create_font_memory(const uint8_t *p_data, size_t p_size, const String &p_type, int p_base_size) {
-	ERR_FAIL_COND_V(interface == nullptr, RID());
-	godot_rid result = interface->create_font_memory(data, p_data, p_size, (godot_string *)&p_type, p_base_size);
-	RID rid = *(RID *)&result;
-	return rid;
+void TextServerGDNative::font_set_data_ptr(RID p_font_rid, const uint8_t *p_data_ptr, size_t p_data_size) {
+	ERR_FAIL_COND(interface == nullptr);
+	interface->font_set_data_ptr(data, (godot_rid *)&p_font_rid, p_data_ptr, p_data_size);
 }
 
-RID TextServerGDNative::create_font_bitmap(float p_height, float p_ascent, int p_base_size) {
-	ERR_FAIL_COND_V(interface == nullptr, RID());
-	godot_rid result = interface->create_font_bitmap(data, p_height, p_ascent, p_base_size);
-	RID rid = *(RID *)&result;
-	return rid;
+void TextServerGDNative::font_set_antialiased(RID p_font_rid, bool p_antialiased) {
+	ERR_FAIL_COND(interface == nullptr);
+	interface->font_set_antialiased(data, (godot_rid *)&p_font_rid, p_antialiased);
 }
 
-void TextServerGDNative::font_bitmap_add_texture(RID p_font, const Ref<Texture> &p_texture) {
+bool TextServerGDNative::font_is_antialiased(RID p_font_rid) const {
+	ERR_FAIL_COND_V(interface == nullptr, false);
+	return interface->font_is_antialiased(data, (godot_rid *)&p_font_rid);
+}
+
+void TextServerGDNative::font_set_multichannel_signed_distance_field(RID p_font_rid, bool p_msdf) {
 	ERR_FAIL_COND(interface == nullptr);
-	interface->font_bitmap_add_texture(data, (godot_rid *)&p_font, (const godot_object *)p_texture.ptr());
+	interface->font_set_multichannel_signed_distance_field(data, (godot_rid *)&p_font_rid, p_msdf);
+}
+
+bool TextServerGDNative::font_is_multichannel_signed_distance_field(RID p_font_rid) const {
+	ERR_FAIL_COND_V(interface == nullptr, false);
+	return interface->font_is_multichannel_signed_distance_field(data, (godot_rid *)&p_font_rid);
 }
 
-void TextServerGDNative::font_bitmap_add_char(RID p_font, char32_t p_char, int p_texture_idx, const Rect2 &p_rect, const Size2 &p_align, float p_advance) {
+void TextServerGDNative::font_set_msdf_pixel_range(RID p_font_rid, int p_msdf_pixel_range) {
 	ERR_FAIL_COND(interface == nullptr);
-	interface->font_bitmap_add_char(data, (godot_rid *)&p_font, p_char, p_texture_idx, (const godot_rect2 *)&p_rect, (const godot_vector2 *)&p_align, p_advance);
+	interface->font_set_msdf_pixel_range(data, (godot_rid *)&p_font_rid, p_msdf_pixel_range);
 }
 
-void TextServerGDNative::font_bitmap_add_kerning_pair(RID p_font, char32_t p_A, char32_t p_B, int p_kerning) {
+int TextServerGDNative::font_get_msdf_pixel_range(RID p_font_rid) const {
+	ERR_FAIL_COND_V(interface == nullptr, 0);
+	return interface->font_get_msdf_pixel_range(data, (godot_rid *)&p_font_rid);
+}
+
+void TextServerGDNative::font_set_msdf_size(RID p_font_rid, int p_msdf_size) {
 	ERR_FAIL_COND(interface == nullptr);
-	interface->font_bitmap_add_kerning_pair(data, (godot_rid *)&p_font, p_A, p_B, p_kerning);
+	interface->font_set_msdf_size(data, (godot_rid *)&p_font_rid, p_msdf_size);
 }
 
-float TextServerGDNative::font_get_height(RID p_font, int p_size) const {
-	ERR_FAIL_COND_V(interface == nullptr, 0.f);
-	return interface->font_get_height(data, (godot_rid *)&p_font, p_size);
+int TextServerGDNative::font_get_msdf_size(RID p_font_rid) const {
+	ERR_FAIL_COND_V(interface == nullptr, 0);
+	return interface->font_get_msdf_size(data, (godot_rid *)&p_font_rid);
 }
 
-float TextServerGDNative::font_get_ascent(RID p_font, int p_size) const {
-	ERR_FAIL_COND_V(interface == nullptr, 0.f);
-	return interface->font_get_ascent(data, (godot_rid *)&p_font, p_size);
+void TextServerGDNative::font_set_fixed_size(RID p_font_rid, int p_fixed_size) {
+	ERR_FAIL_COND(interface == nullptr);
+	interface->font_set_fixed_size(data, (godot_rid *)&p_font_rid, p_fixed_size);
 }
 
-float TextServerGDNative::font_get_descent(RID p_font, int p_size) const {
-	ERR_FAIL_COND_V(interface == nullptr, 0.f);
-	return interface->font_get_descent(data, (godot_rid *)&p_font, p_size);
+int TextServerGDNative::font_get_fixed_size(RID p_font_rid) const {
+	ERR_FAIL_COND_V(interface == nullptr, 0);
+	return interface->font_get_fixed_size(data, (godot_rid *)&p_font_rid);
 }
 
-float TextServerGDNative::font_get_underline_position(RID p_font, int p_size) const {
-	ERR_FAIL_COND_V(interface == nullptr, 0.f);
-	return interface->font_get_underline_position(data, (godot_rid *)&p_font, p_size);
+void TextServerGDNative::font_set_force_autohinter(RID p_font_rid, bool p_force_autohinter) {
+	ERR_FAIL_COND(interface == nullptr);
+	interface->font_set_force_autohinter(data, (godot_rid *)&p_font_rid, p_force_autohinter);
 }
 
-float TextServerGDNative::font_get_underline_thickness(RID p_font, int p_size) const {
-	ERR_FAIL_COND_V(interface == nullptr, 0.f);
-	return interface->font_get_underline_thickness(data, (godot_rid *)&p_font, p_size);
+bool TextServerGDNative::font_is_force_autohinter(RID p_font_rid) const {
+	ERR_FAIL_COND_V(interface == nullptr, false);
+	return interface->font_is_force_autohinter(data, (godot_rid *)&p_font_rid);
 }
 
-int TextServerGDNative::font_get_spacing_space(RID p_font) const {
-	ERR_FAIL_COND_V(interface == nullptr, 0);
-	return interface->font_get_spacing_space(data, (godot_rid *)&p_font);
+void TextServerGDNative::font_set_hinting(RID p_font_rid, TextServer::Hinting p_hinting) {
+	ERR_FAIL_COND(interface == nullptr);
+	interface->font_set_hinting(data, (godot_rid *)&p_font_rid, (godot_int)p_hinting);
 }
 
-void TextServerGDNative::font_set_spacing_space(RID p_font, int p_value) {
+TextServer::Hinting TextServerGDNative::font_get_hinting(RID p_font_rid) const {
+	ERR_FAIL_COND_V(interface == nullptr, TextServer::HINTING_NONE);
+	return (TextServer::Hinting)interface->font_get_hinting(data, (godot_rid *)&p_font_rid);
+}
+
+void TextServerGDNative::font_set_variation_coordinates(RID p_font_rid, const Dictionary &p_variation_coordinates) {
+	ERR_FAIL_COND(interface == nullptr);
+	interface->font_set_variation_coordinates(data, (godot_rid *)&p_font_rid, (const godot_dictionary *)&p_variation_coordinates);
+}
+
+Dictionary TextServerGDNative::font_get_variation_coordinates(RID p_font_rid) const {
+	ERR_FAIL_COND_V(interface == nullptr, Dictionary());
+	godot_dictionary result = interface->font_get_variation_coordinates(data, (godot_rid *)&p_font_rid);
+	Dictionary dict = *(Dictionary *)&result;
+	godot_dictionary_destroy(&result);
+	return dict;
+}
+
+void TextServerGDNative::font_set_oversampling(RID p_font_rid, real_t p_oversampling) {
+	ERR_FAIL_COND(interface == nullptr);
+	interface->font_set_oversampling(data, (godot_rid *)&p_font_rid, p_oversampling);
+}
+
+real_t TextServerGDNative::font_get_oversampling(RID p_font_rid) const {
+	ERR_FAIL_COND_V(interface == nullptr, 0.0f);
+	return interface->font_get_oversampling(data, (godot_rid *)&p_font_rid);
+}
+
+Array TextServerGDNative::font_get_size_cache_list(RID p_font_rid) const {
+	ERR_FAIL_COND_V(interface == nullptr, Array());
+	godot_array result = interface->font_get_size_cache_list(data, (godot_rid *)&p_font_rid);
+	Array list = *(Array *)&result;
+	godot_array_destroy(&result);
+	return list;
+}
+
+void TextServerGDNative::font_clear_size_cache(RID p_font_rid) {
+	ERR_FAIL_COND(interface == nullptr);
+	interface->font_clear_size_cache(data, (godot_rid *)&p_font_rid);
+}
+
+void TextServerGDNative::font_remove_size_cache(RID p_font_rid, const Vector2i &p_size) {
+	ERR_FAIL_COND(interface == nullptr);
+	interface->font_remove_size_cache(data, (godot_rid *)&p_font_rid, (const godot_vector2i *)&p_size);
+}
+
+void TextServerGDNative::font_set_ascent(RID p_font_rid, int p_size, real_t p_ascent) {
 	ERR_FAIL_COND(interface == nullptr);
-	interface->font_set_spacing_space(data, (godot_rid *)&p_font, p_value);
+	interface->font_set_ascent(data, (godot_rid *)&p_font_rid, p_size, p_ascent);
+}
+
+real_t TextServerGDNative::font_get_ascent(RID p_font_rid, int p_size) const {
+	ERR_FAIL_COND_V(interface == nullptr, 0.0f);
+	return interface->font_get_ascent(data, (godot_rid *)&p_font_rid, p_size);
 }
 
-int TextServerGDNative::font_get_spacing_glyph(RID p_font) const {
+void TextServerGDNative::font_set_descent(RID p_font_rid, int p_size, real_t p_descent) {
+	ERR_FAIL_COND(interface == nullptr);
+	interface->font_set_descent(data, (godot_rid *)&p_font_rid, p_size, p_descent);
+}
+
+real_t TextServerGDNative::font_get_descent(RID p_font_rid, int p_size) const {
+	ERR_FAIL_COND_V(interface == nullptr, 0.0f);
+	return interface->font_get_descent(data, (godot_rid *)&p_font_rid, p_size);
+}
+
+void TextServerGDNative::font_set_underline_position(RID p_font_rid, int p_size, real_t p_underline_position) {
+	ERR_FAIL_COND(interface == nullptr);
+	interface->font_set_underline_position(data, (godot_rid *)&p_font_rid, p_size, p_underline_position);
+}
+
+real_t TextServerGDNative::font_get_underline_position(RID p_font_rid, int p_size) const {
+	ERR_FAIL_COND_V(interface == nullptr, 0.0f);
+	return interface->font_get_underline_position(data, (godot_rid *)&p_font_rid, p_size);
+}
+
+void TextServerGDNative::font_set_underline_thickness(RID p_font_rid, int p_size, real_t p_underline_thickness) {
+	ERR_FAIL_COND(interface == nullptr);
+	interface->font_set_underline_thickness(data, (godot_rid *)&p_font_rid, p_size, p_underline_thickness);
+}
+
+real_t TextServerGDNative::font_get_underline_thickness(RID p_font_rid, int p_size) const {
+	ERR_FAIL_COND_V(interface == nullptr, 0.0f);
+	return interface->font_get_underline_thickness(data, (godot_rid *)&p_font_rid, p_size);
+}
+
+void TextServerGDNative::font_set_scale(RID p_font_rid, int p_size, real_t p_scale) {
+	ERR_FAIL_COND(interface == nullptr);
+	interface->font_set_scale(data, (godot_rid *)&p_font_rid, p_size, p_scale);
+}
+
+real_t TextServerGDNative::font_get_scale(RID p_font_rid, int p_size) const {
+	ERR_FAIL_COND_V(interface == nullptr, 0.0f);
+	return interface->font_get_scale(data, (godot_rid *)&p_font_rid, p_size);
+}
+
+void TextServerGDNative::font_set_spacing(RID p_font_rid, int p_size, TextServer::SpacingType p_spacing, int p_value) {
+	ERR_FAIL_COND(interface == nullptr);
+	interface->font_set_spacing(data, (godot_rid *)&p_font_rid, p_size, (godot_int)p_spacing, p_value);
+}
+
+int TextServerGDNative::font_get_spacing(RID p_font_rid, int p_size, TextServer::SpacingType p_spacing) const {
 	ERR_FAIL_COND_V(interface == nullptr, 0);
-	return interface->font_get_spacing_glyph(data, (godot_rid *)&p_font);
+	return interface->font_get_spacing(data, (godot_rid *)&p_font_rid, p_size, (godot_int)p_spacing);
 }
 
-void TextServerGDNative::font_set_spacing_glyph(RID p_font, int p_value) {
+int TextServerGDNative::font_get_texture_count(RID p_font_rid, const Vector2i &p_size) const {
+	ERR_FAIL_COND_V(interface == nullptr, -1);
+	return interface->font_get_texture_count(data, (godot_rid *)&p_font_rid, (const godot_vector2i *)&p_size);
+}
+
+void TextServerGDNative::font_clear_textures(RID p_font_rid, const Vector2i &p_size) {
 	ERR_FAIL_COND(interface == nullptr);
-	interface->font_set_spacing_glyph(data, (godot_rid *)&p_font, p_value);
+	interface->font_clear_textures(data, (godot_rid *)&p_font_rid, (const godot_vector2i *)&p_size);
 }
 
-void TextServerGDNative::font_set_antialiased(RID p_font, bool p_antialiased) {
+void TextServerGDNative::font_remove_texture(RID p_font_rid, const Vector2i &p_size, int p_texture_index) {
 	ERR_FAIL_COND(interface == nullptr);
-	interface->font_set_antialiased(data, (godot_rid *)&p_font, p_antialiased);
+	interface->font_remove_texture(data, (godot_rid *)&p_font_rid, (const godot_vector2i *)&p_size, p_texture_index);
 }
 
-bool TextServerGDNative::font_get_antialiased(RID p_font) const {
-	ERR_FAIL_COND_V(interface == nullptr, false);
-	return interface->font_get_antialiased(data, (godot_rid *)&p_font);
+void TextServerGDNative::font_set_texture_image(RID p_font_rid, const Vector2i &p_size, int p_texture_index, const Ref<Image> &p_image) {
+	ERR_FAIL_COND(interface == nullptr);
+	interface->font_set_texture_image(data, (godot_rid *)&p_font_rid, (const godot_vector2i *)&p_size, p_texture_index, (const godot_object *)p_image.ptr());
 }
 
-Dictionary TextServerGDNative::font_get_variation_list(RID p_font) const {
-	ERR_FAIL_COND_V(interface == nullptr, Dictionary());
-	godot_dictionary result = interface->font_get_variation_list(data, (godot_rid *)&p_font);
-	Dictionary info = *(Dictionary *)&result;
-	godot_dictionary_destroy(&result);
+Ref<Image> TextServerGDNative::font_get_texture_image(RID p_font_rid, const Vector2i &p_size, int p_texture_index) const {
+	ERR_FAIL_COND_V(interface == nullptr, Ref<Image>());
+	godot_object *result = interface->font_get_texture_image(data, (godot_rid *)&p_font_rid, (const godot_vector2i *)&p_size, p_texture_index);
+	return Ref<Image>((Image *)result);
+}
 
-	return info;
+void TextServerGDNative::font_set_texture_offsets(RID p_font_rid, const Vector2i &p_size, int p_texture_index, const PackedInt32Array &p_offset) {
+	ERR_FAIL_COND(interface == nullptr);
+	interface->font_set_texture_offsets(data, (godot_rid *)&p_font_rid, (const godot_vector2i *)&p_size, p_texture_index, (const godot_packed_int32_array *)&p_offset);
+}
+
+PackedInt32Array TextServerGDNative::font_get_texture_offsets(RID p_font_rid, const Vector2i &p_size, int p_texture_index) const {
+	ERR_FAIL_COND_V(interface == nullptr, PackedInt32Array());
+	godot_packed_int32_array result = interface->font_get_texture_offsets(data, (godot_rid *)&p_font_rid, (const godot_vector2i *)&p_size, p_texture_index);
+	PackedInt32Array offset = *(PackedInt32Array *)&result;
+	godot_packed_int32_array_destroy(&result);
+	return offset;
+}
+
+Array TextServerGDNative::font_get_glyph_list(RID p_font_rid, const Vector2i &p_size) const {
+	ERR_FAIL_COND_V(interface == nullptr, Array());
+	godot_array result = interface->font_get_glyph_list(data, (godot_rid *)&p_font_rid, (const godot_vector2i *)&p_size);
+	Array list = *(Array *)&result;
+	godot_array_destroy(&result);
+	return list;
+}
+
+void TextServerGDNative::font_clear_glyphs(RID p_font_rid, const Vector2i &p_size) {
+	ERR_FAIL_COND(interface == nullptr);
+	interface->font_clear_glyphs(data, (godot_rid *)&p_font_rid, (const godot_vector2i *)&p_size);
 }
 
-void TextServerGDNative::font_set_variation(RID p_font, const String &p_name, double p_value) {
+void TextServerGDNative::font_remove_glyph(RID p_font_rid, const Vector2i &p_size, int32_t p_glyph) {
 	ERR_FAIL_COND(interface == nullptr);
-	interface->font_set_variation(data, (godot_rid *)&p_font, (godot_string *)&p_name, p_value);
+	interface->font_remove_glyph(data, (godot_rid *)&p_font_rid, (const godot_vector2i *)&p_size, p_glyph);
 }
 
-double TextServerGDNative::font_get_variation(RID p_font, const String &p_name) const {
-	return interface->font_get_variation(data, (godot_rid *)&p_font, (godot_string *)&p_name);
+Vector2 TextServerGDNative::font_get_glyph_advance(RID p_font_rid, int p_size, int32_t p_glyph) const {
+	ERR_FAIL_COND_V(interface == nullptr, Vector2());
+	godot_vector2 result = interface->font_get_glyph_advance(data, (godot_rid *)&p_font_rid, p_size, p_glyph);
+	Vector2 adv = *(Vector2 *)&result;
+	return adv;
 }
 
-void TextServerGDNative::font_set_hinting(RID p_font, TextServer::Hinting p_hinting) {
+void TextServerGDNative::font_set_glyph_advance(RID p_font_rid, int p_size, int32_t p_glyph, const Vector2 &p_advance) {
 	ERR_FAIL_COND(interface == nullptr);
-	interface->font_set_hinting(data, (godot_rid *)&p_font, (godot_int)p_hinting);
+	interface->font_set_glyph_advance(data, (godot_rid *)&p_font_rid, p_size, p_glyph, (const godot_vector2 *)&p_advance);
 }
 
-TextServer::Hinting TextServerGDNative::font_get_hinting(RID p_font) const {
-	ERR_FAIL_COND_V(interface == nullptr, TextServer::HINTING_NONE);
-	return (TextServer::Hinting)interface->font_get_hinting(data, (godot_rid *)&p_font);
+Vector2 TextServerGDNative::font_get_glyph_offset(RID p_font_rid, const Vector2i &p_size, int32_t p_glyph) const {
+	ERR_FAIL_COND_V(interface == nullptr, Vector2());
+	godot_vector2 result = interface->font_get_glyph_offset(data, (godot_rid *)&p_font_rid, (const godot_vector2i *)&p_size, p_glyph);
+	Vector2 off = *(Vector2 *)&result;
+	return off;
 }
 
-Dictionary TextServerGDNative::font_get_feature_list(RID p_font) const {
-	ERR_FAIL_COND_V(interface == nullptr, Dictionary());
-	godot_dictionary result = interface->font_get_feature_list(data, (godot_rid *)&p_font);
-	Dictionary info = *(Dictionary *)&result;
-	godot_dictionary_destroy(&result);
+void TextServerGDNative::font_set_glyph_offset(RID p_font_rid, const Vector2i &p_size, int32_t p_glyph, const Vector2 &p_offset) {
+	ERR_FAIL_COND(interface == nullptr);
+	interface->font_set_glyph_offset(data, (godot_rid *)&p_font_rid, (const godot_vector2i *)&p_size, p_glyph, (const godot_vector2 *)&p_offset);
+}
 
-	return info;
+Vector2 TextServerGDNative::font_get_glyph_size(RID p_font_rid, const Vector2i &p_size, int32_t p_glyph) const {
+	ERR_FAIL_COND_V(interface == nullptr, Vector2());
+	godot_vector2 result = interface->font_get_glyph_size(data, (godot_rid *)&p_font_rid, (const godot_vector2i *)&p_size, p_glyph);
+	Vector2 sz = *(Vector2 *)&result;
+	return sz;
 }
 
-void TextServerGDNative::font_set_distance_field_hint(RID p_font, bool p_distance_field) {
+void TextServerGDNative::font_set_glyph_size(RID p_font_rid, const Vector2i &p_size, int32_t p_glyph, const Vector2 &p_gl_size) {
 	ERR_FAIL_COND(interface == nullptr);
-	interface->font_set_distance_field_hint(data, (godot_rid *)&p_font, p_distance_field);
+	interface->font_set_glyph_size(data, (godot_rid *)&p_font_rid, (const godot_vector2i *)&p_size, p_glyph, (const godot_vector2 *)&p_size);
 }
 
-bool TextServerGDNative::font_get_distance_field_hint(RID p_font) const {
-	ERR_FAIL_COND_V(interface == nullptr, false);
-	return interface->font_get_distance_field_hint(data, (godot_rid *)&p_font);
+Rect2 TextServerGDNative::font_get_glyph_uv_rect(RID p_font_rid, const Vector2i &p_size, int32_t p_glyph) const {
+	ERR_FAIL_COND_V(interface == nullptr, Rect2());
+	godot_rect2 result = interface->font_get_glyph_uv_rect(data, (godot_rid *)&p_font_rid, (const godot_vector2i *)&p_size, p_glyph);
+	Rect2 uv = *(Rect2 *)&result;
+	return uv;
 }
 
-void TextServerGDNative::font_set_force_autohinter(RID p_font, bool p_enabeld) {
+void TextServerGDNative::font_set_glyph_uv_rect(RID p_font_rid, const Vector2i &p_size, int32_t p_glyph, const Rect2 &p_uv_rect) {
 	ERR_FAIL_COND(interface == nullptr);
-	interface->font_set_force_autohinter(data, (godot_rid *)&p_font, p_enabeld);
+	interface->font_set_glyph_uv_rect(data, (godot_rid *)&p_font_rid, (const godot_vector2i *)&p_size, p_glyph, (const godot_rect2 *)&p_uv_rect);
 }
 
-bool TextServerGDNative::font_get_force_autohinter(RID p_font) const {
-	ERR_FAIL_COND_V(interface == nullptr, false);
-	return interface->font_get_force_autohinter(data, (godot_rid *)&p_font);
+int TextServerGDNative::font_get_glyph_texture_idx(RID p_font_rid, const Vector2i &p_size, int32_t p_glyph) const {
+	ERR_FAIL_COND_V(interface == nullptr, -1);
+	return interface->font_get_glyph_texture_idx(data, (godot_rid *)&p_font_rid, (const godot_vector2i *)&p_size, p_glyph);
+}
+
+void TextServerGDNative::font_set_glyph_texture_idx(RID p_font_rid, const Vector2i &p_size, int32_t p_glyph, int p_texture_idx) {
+	ERR_FAIL_COND(interface == nullptr);
+	interface->font_set_glyph_texture_idx(data, (godot_rid *)&p_font_rid, (const godot_vector2i *)&p_size, p_glyph, p_texture_idx);
 }
 
-bool TextServerGDNative::font_has_char(RID p_font, char32_t p_char) const {
+bool TextServerGDNative::font_get_glyph_contours(RID p_font_rid, int p_size, int32_t p_index, Vector<Vector3> &r_points, Vector<int32_t> &r_contours, bool &r_orientation) const {
 	ERR_FAIL_COND_V(interface == nullptr, false);
-	return interface->font_has_char(data, (godot_rid *)&p_font, p_char);
+	return interface->font_get_glyph_contours(data, (godot_rid *)&p_font_rid, p_size, p_index, (godot_packed_vector3_array *)&r_points, (godot_packed_int32_array *)&r_contours, &r_orientation);
 }
 
-String TextServerGDNative::font_get_supported_chars(RID p_font) const {
-	ERR_FAIL_COND_V(interface == nullptr, String());
-	godot_string result = interface->font_get_supported_chars(data, (godot_rid *)&p_font);
-	String ret = *(String *)&result;
-	godot_string_destroy(&result);
-	return ret;
+Array TextServerGDNative::font_get_kerning_list(RID p_font_rid, int p_size) const {
+	ERR_FAIL_COND_V(interface == nullptr, Array());
+	godot_array result = interface->font_get_kerning_list(data, (godot_rid *)&p_font_rid, p_size);
+	Array list = *(Array *)&result;
+	godot_array_destroy(&result);
+	return list;
 }
 
-bool TextServerGDNative::font_has_outline(RID p_font) const {
-	ERR_FAIL_COND_V(interface == nullptr, false);
-	return interface->font_has_outline(data, (godot_rid *)&p_font);
+void TextServerGDNative::font_clear_kerning_map(RID p_font_rid, int p_size) {
+	ERR_FAIL_COND(interface == nullptr);
+	interface->font_clear_kerning_map(data, (godot_rid *)&p_font_rid, p_size);
 }
 
-float TextServerGDNative::font_get_base_size(RID p_font) const {
-	ERR_FAIL_COND_V(interface == nullptr, 0.f);
-	return interface->font_get_base_size(data, (godot_rid *)&p_font);
+void TextServerGDNative::font_remove_kerning(RID p_font_rid, int p_size, const Vector2i &p_glyph_pair) {
+	ERR_FAIL_COND(interface == nullptr);
+	interface->font_remove_kerning(data, (godot_rid *)&p_font_rid, p_size, (const godot_vector2i *)&p_glyph_pair);
+}
+
+void TextServerGDNative::font_set_kerning(RID p_font_rid, int p_size, const Vector2i &p_glyph_pair, const Vector2 &p_kerning) {
+	ERR_FAIL_COND(interface == nullptr);
+	interface->font_set_kerning(data, (godot_rid *)&p_font_rid, p_size, (const godot_vector2i *)&p_glyph_pair, (const godot_vector2 *)&p_kerning);
+}
+
+Vector2 TextServerGDNative::font_get_kerning(RID p_font_rid, int p_size, const Vector2i &p_glyph_pair) const {
+	ERR_FAIL_COND_V(interface == nullptr, Vector2());
+	godot_vector2 result = interface->font_get_kerning(data, (godot_rid *)&p_font_rid, p_size, (const godot_vector2i *)&p_glyph_pair);
+	Vector2 kern = *(Vector2 *)&result;
+	return kern;
 }
 
-bool TextServerGDNative::font_is_language_supported(RID p_font, const String &p_language) const {
+int32_t TextServerGDNative::font_get_glyph_index(RID p_font_rid, int p_size, char32_t p_char, char32_t p_variation_selector) const {
+	ERR_FAIL_COND_V(interface == nullptr, 0);
+	return interface->font_get_glyph_index(data, (godot_rid *)&p_font_rid, p_size, p_char, p_variation_selector);
+}
+
+bool TextServerGDNative::font_has_char(RID p_font_rid, char32_t p_char) const {
 	ERR_FAIL_COND_V(interface == nullptr, false);
-	return interface->font_is_language_supported(data, (godot_rid *)&p_font, (godot_string *)&p_language);
+	return interface->font_has_char(data, (godot_rid *)&p_font_rid, p_char);
+}
+
+String TextServerGDNative::font_get_supported_chars(RID p_font_rid) const {
+	ERR_FAIL_COND_V(interface == nullptr, String());
+	godot_string result = interface->font_get_supported_chars(data, (godot_rid *)&p_font_rid);
+	String chars = *(String *)&result;
+	godot_string_destroy(&result);
+	return chars;
 }
 
-void TextServerGDNative::font_set_language_support_override(RID p_font, const String &p_language, bool p_supported) {
+void TextServerGDNative::font_render_range(RID p_font_rid, const Vector2i &p_size, char32_t p_start, char32_t p_end) {
 	ERR_FAIL_COND(interface == nullptr);
-	return interface->font_set_language_support_override(data, (godot_rid *)&p_font, (godot_string *)&p_language, p_supported);
+	interface->font_render_range(data, (godot_rid *)&p_font_rid, (const godot_vector2i *)&p_size, p_start, p_end);
 }
 
-bool TextServerGDNative::font_get_language_support_override(RID p_font, const String &p_language) {
-	ERR_FAIL_COND_V(interface == nullptr, false);
-	return interface->font_get_language_support_override(data, (godot_rid *)&p_font, (godot_string *)&p_language);
+void TextServerGDNative::font_render_glyph(RID p_font_rid, const Vector2i &p_size, int32_t p_index) {
+	ERR_FAIL_COND(interface == nullptr);
+	interface->font_render_glyph(data, (godot_rid *)&p_font_rid, (const godot_vector2i *)&p_size, p_index);
 }
 
-void TextServerGDNative::font_remove_language_support_override(RID p_font, const String &p_language) {
+void TextServerGDNative::font_draw_glyph(RID p_font_rid, RID p_canvas, int p_size, const Vector2 &p_pos, int32_t p_index, const Color &p_color) const {
 	ERR_FAIL_COND(interface == nullptr);
-	interface->font_remove_language_support_override(data, (godot_rid *)&p_font, (godot_string *)&p_language);
+	interface->font_draw_glyph(data, (godot_rid *)&p_font_rid, (godot_rid *)&p_canvas, p_size, (const godot_vector2 *)&p_pos, p_index, (const godot_color *)&p_color);
 }
 
-Vector<String> TextServerGDNative::font_get_language_support_overrides(RID p_font) {
-	ERR_FAIL_COND_V(interface == nullptr, Vector<String>());
-	godot_packed_string_array result = interface->font_get_language_support_overrides(data, (godot_rid *)&p_font);
-	Vector<String> ret = *(Vector<String> *)&result;
-	godot_packed_string_array_destroy(&result);
-	return ret;
+void TextServerGDNative::font_draw_glyph_outline(RID p_font_rid, RID p_canvas, int p_size, int p_outline_size, const Vector2 &p_pos, int32_t p_index, const Color &p_color) const {
+	ERR_FAIL_COND(interface == nullptr);
+	interface->font_draw_glyph_outline(data, (godot_rid *)&p_font_rid, (godot_rid *)&p_canvas, p_size, p_outline_size, (const godot_vector2 *)&p_pos, p_index, (const godot_color *)&p_color);
 }
 
-bool TextServerGDNative::font_is_script_supported(RID p_font, const String &p_script) const {
+bool TextServerGDNative::font_is_language_supported(RID p_font_rid, const String &p_language) const {
 	ERR_FAIL_COND_V(interface == nullptr, false);
-	return interface->font_is_script_supported(data, (godot_rid *)&p_font, (godot_string *)&p_script);
+	return interface->font_is_language_supported(data, (godot_rid *)&p_font_rid, (const godot_string *)&p_language);
 }
 
-void TextServerGDNative::font_set_script_support_override(RID p_font, const String &p_script, bool p_supported) {
+void TextServerGDNative::font_set_language_support_override(RID p_font_rid, const String &p_language, bool p_supported) {
 	ERR_FAIL_COND(interface == nullptr);
-	return interface->font_set_script_support_override(data, (godot_rid *)&p_font, (godot_string *)&p_script, p_supported);
+	interface->font_set_language_support_override(data, (godot_rid *)&p_font_rid, (const godot_string *)&p_language, p_supported);
 }
 
-bool TextServerGDNative::font_get_script_support_override(RID p_font, const String &p_script) {
+bool TextServerGDNative::font_get_language_support_override(RID p_font_rid, const String &p_language) {
 	ERR_FAIL_COND_V(interface == nullptr, false);
-	return interface->font_get_script_support_override(data, (godot_rid *)&p_font, (godot_string *)&p_script);
+	return interface->font_get_language_support_override(data, (godot_rid *)&p_font_rid, (const godot_string *)&p_language);
 }
 
-void TextServerGDNative::font_remove_script_support_override(RID p_font, const String &p_script) {
+void TextServerGDNative::font_remove_language_support_override(RID p_font_rid, const String &p_language) {
 	ERR_FAIL_COND(interface == nullptr);
-	interface->font_remove_script_support_override(data, (godot_rid *)&p_font, (godot_string *)&p_script);
+	interface->font_remove_language_support_override(data, (godot_rid *)&p_font_rid, (const godot_string *)&p_language);
 }
 
-Vector<String> TextServerGDNative::font_get_script_support_overrides(RID p_font) {
-	ERR_FAIL_COND_V(interface == nullptr, Vector<String>());
-	godot_packed_string_array result = interface->font_get_script_support_overrides(data, (godot_rid *)&p_font);
-	Vector<String> ret = *(Vector<String> *)&result;
+Vector<String> TextServerGDNative::font_get_language_support_overrides(RID p_font_rid) {
+	ERR_FAIL_COND_V(interface == nullptr, PackedStringArray());
+	godot_packed_string_array result = interface->font_get_language_support_overrides(data, (godot_rid *)&p_font_rid);
+	PackedStringArray list = *(PackedStringArray *)&result;
 	godot_packed_string_array_destroy(&result);
-	return ret;
+	return list;
 }
 
-uint32_t TextServerGDNative::font_get_glyph_index(RID p_font, char32_t p_char, char32_t p_variation_selector) const {
-	ERR_FAIL_COND_V(interface == nullptr, 0);
-	return interface->font_get_glyph_index(data, (godot_rid *)&p_font, p_char, p_variation_selector);
+bool TextServerGDNative::font_is_script_supported(RID p_font_rid, const String &p_script) const {
+	ERR_FAIL_COND_V(interface == nullptr, false);
+	return interface->font_is_script_supported(data, (godot_rid *)&p_font_rid, (const godot_string *)&p_script);
 }
 
-Vector2 TextServerGDNative::font_get_glyph_advance(RID p_font, uint32_t p_index, int p_size) const {
-	ERR_FAIL_COND_V(interface == nullptr, Vector2());
-	godot_vector2 result = interface->font_get_glyph_advance(data, (godot_rid *)&p_font, p_index, p_size);
-	Vector2 advance = *(Vector2 *)&result;
-	return advance;
+void TextServerGDNative::font_set_script_support_override(RID p_font_rid, const String &p_script, bool p_supported) {
+	ERR_FAIL_COND(interface == nullptr);
+	interface->font_set_script_support_override(data, (godot_rid *)&p_font_rid, (const godot_string *)&p_script, p_supported);
 }
 
-Vector2 TextServerGDNative::font_get_glyph_kerning(RID p_font, uint32_t p_index_a, uint32_t p_index_b, int p_size) const {
-	ERR_FAIL_COND_V(interface == nullptr, Vector2());
-	godot_vector2 result = interface->font_get_glyph_kerning(data, (godot_rid *)&p_font, p_index_a, p_index_b, p_size);
-	Vector2 kerning = *(Vector2 *)&result;
-	return kerning;
+bool TextServerGDNative::font_get_script_support_override(RID p_font_rid, const String &p_script) {
+	ERR_FAIL_COND_V(interface == nullptr, false);
+	return interface->font_get_script_support_override(data, (godot_rid *)&p_font_rid, (const godot_string *)&p_script);
 }
 
-Vector2 TextServerGDNative::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 {
-	ERR_FAIL_COND_V(interface == nullptr, Vector2());
-	godot_vector2 result = interface->font_draw_glyph(data, (godot_rid *)&p_font, (godot_rid *)&p_canvas, p_size, (const godot_vector2 *)&p_pos, p_index, (const godot_color *)&p_color);
-	Vector2 advance = *(Vector2 *)&result;
-	return advance;
+void TextServerGDNative::font_remove_script_support_override(RID p_font_rid, const String &p_script) {
+	ERR_FAIL_COND(interface == nullptr);
+	interface->font_remove_script_support_override(data, (godot_rid *)&p_font_rid, (const godot_string *)&p_script);
 }
 
-Vector2 TextServerGDNative::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 {
-	ERR_FAIL_COND_V(interface == nullptr, Vector2());
-	godot_vector2 result = interface->font_draw_glyph_outline(data, (godot_rid *)&p_font, (godot_rid *)&p_canvas, p_size, p_outline_size, (const godot_vector2 *)&p_pos, p_index, (const godot_color *)&p_color);
-	Vector2 advance = *(Vector2 *)&result;
-	return advance;
+Vector<String> TextServerGDNative::font_get_script_support_overrides(RID p_font_rid) {
+	ERR_FAIL_COND_V(interface == nullptr, PackedStringArray());
+	godot_packed_string_array result = interface->font_get_script_support_overrides(data, (godot_rid *)&p_font_rid);
+	PackedStringArray list = *(PackedStringArray *)&result;
+	godot_packed_string_array_destroy(&result);
+	return list;
 }
 
-bool TextServerGDNative::font_get_glyph_contours(RID p_font, int p_size, uint32_t p_index, Vector<Vector3> &r_points, Vector<int32_t> &r_contours, bool &r_orientation) const {
-	ERR_FAIL_COND_V(interface == nullptr, false);
-	ERR_FAIL_COND_V(interface->font_get_glyph_contours == nullptr, false);
-	return interface->font_get_glyph_contours(data, (godot_rid *)&p_font, p_size, p_index, (godot_packed_vector3_array *)&r_points, (godot_packed_int32_array *)&r_contours, (bool *)&r_orientation);
+Dictionary TextServerGDNative::font_supported_feature_list(RID p_font_rid) const {
+	ERR_FAIL_COND_V(interface == nullptr, Dictionary());
+	godot_dictionary result = interface->font_supported_feature_list(data, (godot_rid *)&p_font_rid);
+	Dictionary dict = *(Dictionary *)&result;
+	godot_dictionary_destroy(&result);
+	return dict;
 }
 
-float TextServerGDNative::font_get_oversampling() const {
-	ERR_FAIL_COND_V(interface == nullptr, 1.f);
-	return interface->font_get_oversampling(data);
+Dictionary TextServerGDNative::font_supported_variation_list(RID p_font_rid) const {
+	ERR_FAIL_COND_V(interface == nullptr, Dictionary());
+	godot_dictionary result = interface->font_supported_variation_list(data, (godot_rid *)&p_font_rid);
+	Dictionary dict = *(Dictionary *)&result;
+	godot_dictionary_destroy(&result);
+	return dict;
 }
 
-void TextServerGDNative::font_set_oversampling(float p_oversampling) {
-	ERR_FAIL_COND(interface == nullptr);
-	return interface->font_set_oversampling(data, p_oversampling);
+real_t TextServerGDNative::font_get_global_oversampling() const {
+	ERR_FAIL_COND_V(interface == nullptr, 0.0f);
+	return interface->font_get_global_oversampling(data);
 }
 
-Vector<String> TextServerGDNative::get_system_fonts() const {
-	ERR_FAIL_COND_V(interface == nullptr, Vector<String>());
-	godot_packed_string_array result = interface->get_system_fonts(data);
-	Vector<String> fonts = *(Vector<String> *)&result;
-	godot_packed_string_array_destroy(&result);
-	return fonts;
+void TextServerGDNative::font_set_global_oversampling(real_t p_oversampling) {
+	ERR_FAIL_COND(interface == nullptr);
+	interface->font_set_global_oversampling(data, p_oversampling);
 }
 
 /*************************************************************************/
@@ -473,12 +653,12 @@ RID TextServerGDNative::shaped_text_get_parent(RID p_shaped) const {
 	return rid;
 }
 
-float TextServerGDNative::shaped_text_fit_to_width(RID p_shaped, float p_width, uint8_t p_jst_flags) {
+real_t TextServerGDNative::shaped_text_fit_to_width(RID p_shaped, real_t p_width, uint8_t p_jst_flags) {
 	ERR_FAIL_COND_V(interface == nullptr, 0.f);
 	return interface->shaped_text_fit_to_width(data, (godot_rid *)&p_shaped, p_width, p_jst_flags);
 }
 
-float TextServerGDNative::shaped_text_tab_align(RID p_shaped, const Vector<float> &p_tab_stops) {
+real_t TextServerGDNative::shaped_text_tab_align(RID p_shaped, const Vector<real_t> &p_tab_stops) {
 	ERR_FAIL_COND_V(interface == nullptr, 0.f);
 	return interface->shaped_text_tab_align(data, (godot_rid *)&p_shaped, (godot_packed_float32_array *)&p_tab_stops);
 }
@@ -498,7 +678,7 @@ bool TextServerGDNative::shaped_text_update_justification_ops(RID p_shaped) {
 	return interface->shaped_text_update_justification_ops(data, (godot_rid *)&p_shaped);
 }
 
-void TextServerGDNative::shaped_text_overrun_trim_to_width(RID p_shaped_line, float p_width, uint8_t p_trim_flags) {
+void TextServerGDNative::shaped_text_overrun_trim_to_width(RID p_shaped_line, real_t p_width, uint8_t p_trim_flags) {
 	ERR_FAIL_COND(interface == nullptr);
 	interface->shaped_text_overrun_trim_to_width(data, (godot_rid *)&p_shaped_line, p_width, p_trim_flags);
 };
@@ -531,7 +711,7 @@ Vector<TextServer::Glyph> TextServerGDNative::shaped_text_sort_logical(RID p_sha
 	return glyphs;
 }
 
-Vector<Vector2i> TextServerGDNative::shaped_text_get_line_breaks_adv(RID p_shaped, const Vector<float> &p_width, int p_start, bool p_once, uint8_t p_break_flags) const {
+Vector<Vector2i> TextServerGDNative::shaped_text_get_line_breaks_adv(RID p_shaped, const Vector<real_t> &p_width, int p_start, bool p_once, uint8_t p_break_flags) const {
 	ERR_FAIL_COND_V(interface == nullptr, Vector<Vector2i>());
 	if (interface->shaped_text_get_line_breaks_adv != nullptr) {
 		godot_packed_vector2i_array result = interface->shaped_text_get_line_breaks_adv(data, (godot_rid *)&p_shaped, (godot_packed_float32_array *)&p_width, p_start, p_once, p_break_flags);
@@ -543,7 +723,7 @@ Vector<Vector2i> TextServerGDNative::shaped_text_get_line_breaks_adv(RID p_shape
 	}
 }
 
-Vector<Vector2i> TextServerGDNative::shaped_text_get_line_breaks(RID p_shaped, float p_width, int p_start, uint8_t p_break_flags) const {
+Vector<Vector2i> TextServerGDNative::shaped_text_get_line_breaks(RID p_shaped, real_t p_width, int p_start, uint8_t p_break_flags) const {
 	ERR_FAIL_COND_V(interface == nullptr, Vector<Vector2i>());
 	if (interface->shaped_text_get_line_breaks != nullptr) {
 		godot_packed_vector2i_array result = interface->shaped_text_get_line_breaks(data, (godot_rid *)&p_shaped, p_width, p_start, p_break_flags);
@@ -588,27 +768,27 @@ Size2 TextServerGDNative::shaped_text_get_size(RID p_shaped) const {
 	return size;
 }
 
-float TextServerGDNative::shaped_text_get_ascent(RID p_shaped) const {
+real_t TextServerGDNative::shaped_text_get_ascent(RID p_shaped) const {
 	ERR_FAIL_COND_V(interface == nullptr, 0.f);
 	return interface->shaped_text_get_ascent(data, (godot_rid *)&p_shaped);
 }
 
-float TextServerGDNative::shaped_text_get_descent(RID p_shaped) const {
+real_t TextServerGDNative::shaped_text_get_descent(RID p_shaped) const {
 	ERR_FAIL_COND_V(interface == nullptr, 0.f);
 	return interface->shaped_text_get_descent(data, (godot_rid *)&p_shaped);
 }
 
-float TextServerGDNative::shaped_text_get_width(RID p_shaped) const {
+real_t TextServerGDNative::shaped_text_get_width(RID p_shaped) const {
 	ERR_FAIL_COND_V(interface == nullptr, 0.f);
 	return interface->shaped_text_get_width(data, (godot_rid *)&p_shaped);
 }
 
-float TextServerGDNative::shaped_text_get_underline_position(RID p_shaped) const {
+real_t TextServerGDNative::shaped_text_get_underline_position(RID p_shaped) const {
 	ERR_FAIL_COND_V(interface == nullptr, 0.f);
 	return interface->shaped_text_get_underline_position(data, (godot_rid *)&p_shaped);
 }
 
-float TextServerGDNative::shaped_text_get_underline_thickness(RID p_shaped) const {
+real_t TextServerGDNative::shaped_text_get_underline_thickness(RID p_shaped) const {
 	ERR_FAIL_COND_V(interface == nullptr, 0.f);
 	return interface->shaped_text_get_underline_thickness(data, (godot_rid *)&p_shaped);
 }
@@ -756,12 +936,12 @@ void GDAPI godot_glyph_set_offset(godot_glyph *p_self, const godot_vector2 *p_of
 	self->y_off = offset->y;
 }
 
-godot_float GDAPI godot_glyph_get_advance(const godot_glyph *p_self) {
+godot_real_t GDAPI godot_glyph_get_advance(const godot_glyph *p_self) {
 	const TextServer::Glyph *self = (const TextServer::Glyph *)p_self;
 	return self->advance;
 }
 
-void GDAPI godot_glyph_set_advance(godot_glyph *p_self, godot_float p_advance) {
+void GDAPI godot_glyph_set_advance(godot_glyph *p_self, godot_real_t p_advance) {
 	TextServer::Glyph *self = (TextServer::Glyph *)p_self;
 	self->advance = p_advance;
 }
diff --git a/modules/gdnative/text/text_server_gdnative.h b/modules/gdnative/text/text_server_gdnative.h
index e1b36f4264..f081637e23 100644
--- a/modules/gdnative/text/text_server_gdnative.h
+++ b/modules/gdnative/text/text_server_gdnative.h
@@ -60,78 +60,130 @@ public:
 
 	virtual bool is_locale_right_to_left(const String &p_locale) override;
 
+	virtual int32_t name_to_tag(const String &p_name) const override;
+	virtual String tag_to_name(int32_t p_tag) const 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 RID create_font_bitmap(float p_height, float p_ascent, int p_base_size = 16) override;
+	virtual RID create_font() override;
+
+	virtual void font_set_data(RID p_font_rid, const PackedByteArray &p_data) override;
+	virtual void font_set_data_ptr(RID p_font_rid, const uint8_t *p_data_ptr, size_t p_data_size) override;
+
+	virtual void font_set_antialiased(RID p_font_rid, bool p_antialiased) override;
+	virtual bool font_is_antialiased(RID p_font_rid) const override;
+
+	virtual void font_set_multichannel_signed_distance_field(RID p_font_rid, bool p_msdf) override;
+	virtual bool font_is_multichannel_signed_distance_field(RID p_font_rid) const override;
+
+	virtual void font_set_msdf_pixel_range(RID p_font_rid, int p_msdf_pixel_range) override;
+	virtual int font_get_msdf_pixel_range(RID p_font_rid) const override;
+
+	virtual void font_set_msdf_size(RID p_font_rid, int p_msdf_size) override;
+	virtual int font_get_msdf_size(RID p_font_rid) const override;
+
+	virtual void font_set_fixed_size(RID p_font_rid, int p_fixed_size) override;
+	virtual int font_get_fixed_size(RID p_font_rid) const override;
+
+	virtual void font_set_force_autohinter(RID p_font_rid, bool p_force_autohinter) override;
+	virtual bool font_is_force_autohinter(RID p_font_rid) const override;
+
+	virtual void font_set_hinting(RID p_font_rid, TextServer::Hinting p_hinting) override;
+	virtual TextServer::Hinting font_get_hinting(RID p_font_rid) const override;
+
+	virtual void font_set_variation_coordinates(RID p_font_rid, const Dictionary &p_variation_coordinates) override;
+	virtual Dictionary font_get_variation_coordinates(RID p_font_rid) const override;
+
+	virtual void font_set_oversampling(RID p_font_rid, real_t p_oversampling) override;
+	virtual real_t font_get_oversampling(RID p_font_rid) const override;
+
+	virtual Array font_get_size_cache_list(RID p_font_rid) const override;
+	virtual void font_clear_size_cache(RID p_font_rid) override;
+	virtual void font_remove_size_cache(RID p_font_rid, const Vector2i &p_size) override;
+
+	virtual void font_set_ascent(RID p_font_rid, int p_size, real_t p_ascent) override;
+	virtual real_t font_get_ascent(RID p_font_rid, int p_size) const override;
+
+	virtual void font_set_descent(RID p_font_rid, int p_size, real_t p_descent) override;
+	virtual real_t font_get_descent(RID p_font_rid, int p_size) const override;
+
+	virtual void font_set_underline_position(RID p_font_rid, int p_size, real_t p_underline_position) override;
+	virtual real_t font_get_underline_position(RID p_font_rid, int p_size) const override;
+
+	virtual void font_set_underline_thickness(RID p_font_rid, int p_size, real_t p_underline_thickness) override;
+	virtual real_t font_get_underline_thickness(RID p_font_rid, int p_size) const override;
+
+	virtual void font_set_scale(RID p_font_rid, int p_size, real_t p_scale) override;
+	virtual real_t font_get_scale(RID p_font_rid, int p_size) const override;
+
+	virtual void font_set_spacing(RID p_font_rid, int p_size, SpacingType p_spacing, int p_value) override;
+	virtual int font_get_spacing(RID p_font_rid, int p_size, SpacingType p_spacing) const override;
 
-	virtual void font_bitmap_add_texture(RID p_font, const Ref<Texture> &p_texture) override;
-	virtual void font_bitmap_add_char(RID p_font, char32_t p_char, int p_texture_idx, const Rect2 &p_rect, const Size2 &p_align, float p_advance) override;
-	virtual void font_bitmap_add_kerning_pair(RID p_font, char32_t p_A, char32_t p_B, int p_kerning) override;
+	virtual int font_get_texture_count(RID p_font_rid, const Vector2i &p_size) const override;
+	virtual void font_clear_textures(RID p_font_rid, const Vector2i &p_size) override;
+	virtual void font_remove_texture(RID p_font_rid, const Vector2i &p_size, int p_texture_index) 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 void font_set_texture_image(RID p_font_rid, const Vector2i &p_size, int p_texture_index, const Ref<Image> &p_image) override;
+	virtual Ref<Image> font_get_texture_image(RID p_font_rid, const Vector2i &p_size, int p_texture_index) 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_texture_offsets(RID p_font_rid, const Vector2i &p_size, int p_texture_index, const PackedInt32Array &p_offset) override;
+	virtual PackedInt32Array font_get_texture_offsets(RID p_font_rid, const Vector2i &p_size, int p_texture_index) const override;
 
-	virtual int font_get_spacing_space(RID p_font) const override;
-	virtual void font_set_spacing_space(RID p_font, int p_value) override;
+	virtual Array font_get_glyph_list(RID p_font_rid, const Vector2i &p_size) const override;
+	virtual void font_clear_glyphs(RID p_font_rid, const Vector2i &p_size) override;
+	virtual void font_remove_glyph(RID p_font_rid, const Vector2i &p_size, int32_t p_glyph) override;
 
-	virtual int font_get_spacing_glyph(RID p_font) const override;
-	virtual void font_set_spacing_glyph(RID p_font, int p_value) override;
+	virtual Vector2 font_get_glyph_advance(RID p_font_rid, int p_size, int32_t p_glyph) const override;
+	virtual void font_set_glyph_advance(RID p_font_rid, int p_size, int32_t p_glyph, const Vector2 &p_advance) override;
 
-	virtual void font_set_antialiased(RID p_font, bool p_antialiased) override;
-	virtual bool font_get_antialiased(RID p_font) const override;
+	virtual Vector2 font_get_glyph_offset(RID p_font_rid, const Vector2i &p_size, int32_t p_glyph) const override;
+	virtual void font_set_glyph_offset(RID p_font_rid, const Vector2i &p_size, int32_t p_glyph, const Vector2 &p_offset) override;
 
-	virtual Dictionary font_get_feature_list(RID p_font) const override;
-	virtual Dictionary font_get_variation_list(RID p_font) const override;
+	virtual Vector2 font_get_glyph_size(RID p_font_rid, const Vector2i &p_size, int32_t p_glyph) const override;
+	virtual void font_set_glyph_size(RID p_font_rid, const Vector2i &p_size, int32_t p_glyph, const Vector2 &p_gl_size) override;
 
-	virtual void font_set_variation(RID p_font, const String &p_name, double p_value) override;
-	virtual double font_get_variation(RID p_font, const String &p_name) const override;
+	virtual Rect2 font_get_glyph_uv_rect(RID p_font_rid, const Vector2i &p_size, int32_t p_glyph) const override;
+	virtual void font_set_glyph_uv_rect(RID p_font_rid, const Vector2i &p_size, int32_t p_glyph, const Rect2 &p_uv_rect) override;
 
-	virtual void font_set_hinting(RID p_font, Hinting p_hinting) override;
-	virtual Hinting font_get_hinting(RID p_font) const override;
+	virtual int font_get_glyph_texture_idx(RID p_font_rid, const Vector2i &p_size, int32_t p_glyph) const override;
+	virtual void font_set_glyph_texture_idx(RID p_font_rid, const Vector2i &p_size, int32_t p_glyph, int p_texture_idx) 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 bool font_get_glyph_contours(RID p_font, int p_size, int32_t p_index, Vector<Vector3> &r_points, Vector<int32_t> &r_contours, bool &r_orientation) 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 Array font_get_kerning_list(RID p_font_rid, int p_size) const override;
+	virtual void font_clear_kerning_map(RID p_font_rid, int p_size) override;
+	virtual void font_remove_kerning(RID p_font_rid, int p_size, const Vector2i &p_glyph_pair) 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 void font_set_kerning(RID p_font_rid, int p_size, const Vector2i &p_glyph_pair, const Vector2 &p_kerning) override;
+	virtual Vector2 font_get_kerning(RID p_font_rid, int p_size, const Vector2i &p_glyph_pair) const override;
 
-	virtual bool font_has_outline(RID p_font) const override;
-	virtual float font_get_base_size(RID p_font) const override;
+	virtual int32_t font_get_glyph_index(RID p_font_rid, int p_size, char32_t p_char, char32_t p_variation_selector = 0) 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_has_char(RID p_font_rid, char32_t p_char) const override;
+	virtual String font_get_supported_chars(RID p_font_rid) const 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 void font_render_range(RID p_font, const Vector2i &p_size, char32_t p_start, char32_t p_end) override;
+	virtual void font_render_glyph(RID p_font_rid, const Vector2i &p_size, int32_t p_index) 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 void font_draw_glyph(RID p_font, RID p_canvas, int p_size, const Vector2 &p_pos, int32_t p_index, const Color &p_color = Color(1, 1, 1)) const override;
+	virtual void font_draw_glyph_outline(RID p_font, RID p_canvas, int p_size, int p_outline_size, const Vector2 &p_pos, int32_t p_index, const Color &p_color = Color(1, 1, 1)) 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 bool font_is_language_supported(RID p_font_rid, const String &p_language) const override;
+	virtual void font_set_language_support_override(RID p_font_rid, const String &p_language, bool p_supported) override;
+	virtual bool font_get_language_support_override(RID p_font_rid, const String &p_language) override;
+	virtual void font_remove_language_support_override(RID p_font_rid, const String &p_language) override;
+	virtual Vector<String> font_get_language_support_overrides(RID p_font_rid) override;
 
-	virtual bool font_get_glyph_contours(RID p_font, int p_size, uint32_t p_index, Vector<Vector3> &r_points, Vector<int32_t> &r_contours, bool &r_orientation) const override;
+	virtual bool font_is_script_supported(RID p_font_rid, const String &p_script) const override;
+	virtual void font_set_script_support_override(RID p_font_rid, const String &p_script, bool p_supported) override;
+	virtual bool font_get_script_support_override(RID p_font_rid, const String &p_script) override;
+	virtual void font_remove_script_support_override(RID p_font_rid, const String &p_script) override;
+	virtual Vector<String> font_get_script_support_overrides(RID p_font_rid) override;
 
-	virtual float font_get_oversampling() const override;
-	virtual void font_set_oversampling(float p_oversampling) override;
+	virtual Dictionary font_supported_feature_list(RID p_font_rid) const override;
+	virtual Dictionary font_supported_variation_list(RID p_font_rid) const override;
 
-	virtual Vector<String> get_system_fonts() const override;
+	virtual real_t font_get_global_oversampling() const override;
+	virtual void font_set_global_oversampling(real_t p_oversampling) override;
 
 	/* Shaped text buffer interface */
 
@@ -160,14 +212,14 @@ public:
 	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 real_t shaped_text_fit_to_width(RID p_shaped, real_t p_width, uint8_t /*JustificationFlag*/ p_jst_flags = JUSTIFICATION_WORD_BOUND | JUSTIFICATION_KASHIDA) override;
+	virtual real_t shaped_text_tab_align(RID p_shaped, const Vector<real_t> &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 void shaped_text_overrun_trim_to_width(RID p_shaped, float p_width, uint8_t p_trim_flags) override;
+	virtual void shaped_text_overrun_trim_to_width(RID p_shaped, real_t p_width, uint8_t p_trim_flags) override;
 
 	virtual bool shaped_text_is_ready(RID p_shaped) const override;
 
@@ -176,18 +228,18 @@ public:
 	virtual Vector2i shaped_text_get_range(RID p_shaped) const override;
 
 	virtual Vector<Glyph> shaped_text_sort_logical(RID p_shaped) override;
-	virtual Vector<Vector2i> shaped_text_get_line_breaks_adv(RID p_shaped, const Vector<float> &p_width, int p_start = 0, bool p_once = true, uint8_t /*TextBreakFlag*/ p_break_flags = BREAK_MANDATORY | BREAK_WORD_BOUND) const override;
-	virtual Vector<Vector2i> shaped_text_get_line_breaks(RID p_shaped, float p_width, int p_start = 0, uint8_t p_break_flags = BREAK_MANDATORY | BREAK_WORD_BOUND) const override;
+	virtual Vector<Vector2i> shaped_text_get_line_breaks_adv(RID p_shaped, const Vector<real_t> &p_width, int p_start = 0, bool p_once = true, uint8_t /*TextBreakFlag*/ p_break_flags = BREAK_MANDATORY | BREAK_WORD_BOUND) const override;
+	virtual Vector<Vector2i> shaped_text_get_line_breaks(RID p_shaped, real_t p_width, int p_start = 0, uint8_t p_break_flags = BREAK_MANDATORY | BREAK_WORD_BOUND) const override;
 	virtual Vector<Vector2i> shaped_text_get_word_breaks(RID p_shaped, int p_grapheme_flags = GRAPHEME_IS_SPACE | GRAPHEME_IS_PUNCTUATION) const 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 real_t shaped_text_get_ascent(RID p_shaped) const override;
+	virtual real_t shaped_text_get_descent(RID p_shaped) const override;
+	virtual real_t shaped_text_get_width(RID p_shaped) const override;
+	virtual real_t shaped_text_get_underline_position(RID p_shaped) const override;
+	virtual real_t 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;
diff --git a/modules/msdfgen/SCsub b/modules/msdfgen/SCsub
new file mode 100644
index 0000000000..227369f4bd
--- /dev/null
+++ b/modules/msdfgen/SCsub
@@ -0,0 +1,66 @@
+#!/usr/bin/env python
+
+Import("env")
+Import("env_modules")
+
+env_msdfgen = env_modules.Clone()
+
+# Thirdparty source files
+
+thirdparty_obj = []
+
+if env["builtin_msdfgen"]:
+    env_msdfgen.disable_warnings()
+
+    thirdparty_dir = "#thirdparty/msdfgen/"
+    thirdparty_sources = [
+        "core/Contour.cpp",
+        "core/EdgeHolder.cpp",
+        "core/MSDFErrorCorrection.cpp",
+        "core/Projection.cpp",
+        "core/Scanline.cpp",
+        "core/Shape.cpp",
+        "core/SignedDistance.cpp",
+        "core/Vector2.cpp",
+        "core/contour-combiners.cpp",
+        "core/edge-coloring.cpp",
+        "core/edge-segments.cpp",
+        "core/edge-selectors.cpp",
+        "core/equation-solver.cpp",
+        "core/msdf-error-correction.cpp",
+        "core/msdfgen.cpp",
+        "core/rasterization.cpp",
+        "core/render-sdf.cpp",
+        "core/sdf-error-estimation.cpp",
+        "core/shape-description.cpp",
+    ]
+    thirdparty_sources = [thirdparty_dir + file for file in thirdparty_sources]
+
+    env_msdfgen.Append(CPPPATH=["#thirdparty/freetype/include", "#thirdparty/msdfgen", "#thirdparty/nanosvg"])
+
+    lib = env_msdfgen.add_library("msdfgen_builtin", thirdparty_sources)
+    thirdparty_obj += lib
+
+    # Needs to be appended to arrive after libscene in the linker call,
+    # but we don't want it to arrive *after* system libs, so manual hack
+    # LIBS contains first SCons Library objects ("SCons.Node.FS.File object")
+    # and then plain strings for system library. We insert between the two.
+    inserted = False
+    for idx, linklib in enumerate(env["LIBS"]):
+        if isinstance(linklib, (str, bytes)):  # first system lib such as "X11", otherwise SCons lib object
+            env["LIBS"].insert(idx, lib)
+            inserted = True
+            break
+    if not inserted:
+        env.Append(LIBS=[lib])
+
+
+# Godot source files
+
+module_obj = []
+
+env_msdfgen.add_source_files(module_obj, "*.cpp")
+env.modules_sources += module_obj
+
+# Needed to force rebuilding the module files when the thirdparty library is updated.
+env.Depends(module_obj, thirdparty_obj)
diff --git a/modules/msdfgen/config.py b/modules/msdfgen/config.py
new file mode 100644
index 0000000000..653e466a74
--- /dev/null
+++ b/modules/msdfgen/config.py
@@ -0,0 +1,6 @@
+def can_build(env, platform):
+    return env.module_check_dependencies("msdfgen", ["freetype"])
+
+
+def configure(env):
+    pass
diff --git a/modules/msdfgen/register_types.cpp b/modules/msdfgen/register_types.cpp
new file mode 100644
index 0000000000..ad60a66d2d
--- /dev/null
+++ b/modules/msdfgen/register_types.cpp
@@ -0,0 +1,35 @@
+/*************************************************************************/
+/*  register_types.cpp                                                   */
+/*************************************************************************/
+/*                       This file is part of:                           */
+/*                           GODOT ENGINE                                */
+/*                      https://godotengine.org                          */
+/*************************************************************************/
+/* Copyright (c) 2007-2021 Juan Linietsky, Ariel Manzur.                 */
+/* Copyright (c) 2014-2021 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"
+
+void register_msdfgen_types() {}
+
+void unregister_msdfgen_types() {}
diff --git a/modules/msdfgen/register_types.h b/modules/msdfgen/register_types.h
new file mode 100644
index 0000000000..fb776c14ed
--- /dev/null
+++ b/modules/msdfgen/register_types.h
@@ -0,0 +1,37 @@
+/*************************************************************************/
+/*  register_types.h                                                     */
+/*************************************************************************/
+/*                       This file is part of:                           */
+/*                           GODOT ENGINE                                */
+/*                      https://godotengine.org                          */
+/*************************************************************************/
+/* Copyright (c) 2007-2021 Juan Linietsky, Ariel Manzur.                 */
+/* Copyright (c) 2014-2021 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 MSDFGEN_REGISTER_TYPES_H
+#define MSDFGEN_REGISTER_TYPES_H
+
+void register_msdfgen_types();
+void unregister_msdfgen_types();
+
+#endif // MSDFGEN_REGISTER_TYPES_H
diff --git a/modules/text_server_adv/SCsub b/modules/text_server_adv/SCsub
index 1fcbb7aaca..6691f86e60 100644
--- a/modules/text_server_adv/SCsub
+++ b/modules/text_server_adv/SCsub
@@ -38,7 +38,8 @@ def make_icu_data(target, source, env):
 # Thirdparty source files
 
 thirdparty_obj = []
-freetype_enabled = env.module_check_dependencies("text_server_adv", ["freetype"])
+freetype_enabled = env.module_check_dependencies("text_server_adv", ["freetype"], True)
+msdngen_enabled = env.module_check_dependencies("text_server_adv", ["msdfgen"], True)
 
 if env["builtin_harfbuzz"]:
     env_harfbuzz = env_modules.Clone()
@@ -509,6 +510,13 @@ env_text_server_adv.Append(
     ]
 )
 
+if msdngen_enabled:
+    env_text_server_adv.Append(
+        CPPPATH=[
+            "#thirdparty/msdfgen",
+        ]
+    )
+
 if freetype_enabled:
     env_text_server_adv.Append(
         CPPPATH=[
diff --git a/modules/text_server_adv/bitmap_font_adv.cpp b/modules/text_server_adv/bitmap_font_adv.cpp
deleted file mode 100644
index 1731fb6223..0000000000
--- a/modules/text_server_adv/bitmap_font_adv.cpp
+++ /dev/null
@@ -1,585 +0,0 @@
-/*************************************************************************/
-/*  bitmap_font_adv.cpp                                                  */
-/*************************************************************************/
-/*                       This file is part of:                           */
-/*                           GODOT ENGINE                                */
-/*                      https://godotengine.org                          */
-/*************************************************************************/
-/* Copyright (c) 2007-2021 Juan Linietsky, Ariel Manzur.                 */
-/* Copyright (c) 2014-2021 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.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 *funcs = nullptr;
-void hb_bmp_create_font_funcs() {
-	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);
-}
-
-void hb_bmp_free_font_funcs() {
-	if (funcs != nullptr) {
-		hb_font_funcs_destroy(funcs);
-		funcs = nullptr;
-	}
-}
-
-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, 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
-	//https://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.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;
-	}
-
-	if (hb_handle) {
-		hb_font_destroy(hb_handle);
-	}
-	hb_handle = hb_bmp_font_create(this, base_size, nullptr);
-	valid = true;
-
-	memdelete(f);
-	return OK;
-}
-
-Error BitmapFontDataAdvanced::bitmap_new(float p_height, float p_ascent, int p_base_size) {
-	height = p_height;
-	ascent = p_ascent;
-
-	base_size = p_base_size;
-	if (base_size == 0) {
-		base_size = height;
-	}
-
-	char_map.clear();
-	textures.clear();
-	kerning_map.clear();
-	if (hb_handle) {
-		hb_font_destroy(hb_handle);
-	}
-	hb_handle = hb_bmp_font_create(this, base_size, nullptr);
-	valid = true;
-
-	return OK;
-}
-
-void BitmapFontDataAdvanced::bitmap_add_texture(const Ref<Texture> &p_texture) {
-	ERR_FAIL_COND(!valid);
-	ERR_FAIL_COND_MSG(p_texture.is_null(), "It's not a reference to a valid Texture object.");
-
-	textures.push_back(p_texture);
-}
-
-void BitmapFontDataAdvanced::bitmap_add_char(char32_t p_char, int p_texture_idx, const Rect2 &p_rect, const Size2 &p_align, float p_advance) {
-	ERR_FAIL_COND(!valid);
-
-	Character chr;
-	chr.rect = p_rect;
-	chr.texture_idx = p_texture_idx;
-	if (p_advance < 0) {
-		chr.advance.x = chr.rect.size.x;
-	} else {
-		chr.advance.x = p_advance;
-	}
-	chr.align = p_align;
-	char_map[p_char] = chr;
-}
-
-void BitmapFontDataAdvanced::bitmap_add_kerning_pair(char32_t p_A, char32_t p_B, int p_kerning) {
-	ERR_FAIL_COND(!valid);
-
-	KerningPairKey kpk;
-	kpk.A = p_A;
-	kpk.B = p_B;
-
-	if (p_kerning == 0 && kerning_map.has(kpk)) {
-		kerning_map.erase(kpk);
-	} else {
-		kerning_map[kpk] = p_kerning;
-	}
-}
-
-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);
-	return hb_handle;
-}
-
-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));
-}
-
-float BitmapFontDataAdvanced::get_font_scale(int p_size) const {
-	return 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) {
-		Point2i cpos = p_pos;
-		cpos += (c->align + Vector2(0, -ascent)) * (float(p_size) / float(base_size));
-		Size2i csize = c->rect.size * (float(p_size) / float(base_size));
-		if (RenderingServer::get_singleton() != nullptr) {
-			//if (distance_field_hint) { // Not implemented.
-			//	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, csize), textures[c->texture_idx]->get_rid(), c->rect, p_color, false, 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() {
-	if (hb_handle) {
-		hb_font_destroy(hb_handle);
-	}
-}
diff --git a/modules/text_server_adv/bitmap_font_adv.h b/modules/text_server_adv/bitmap_font_adv.h
deleted file mode 100644
index 7b620021e1..0000000000
--- a/modules/text_server_adv/bitmap_font_adv.h
+++ /dev/null
@@ -1,123 +0,0 @@
-/*************************************************************************/
-/*  bitmap_font_adv.h                                                    */
-/*************************************************************************/
-/*                       This file is part of:                           */
-/*                           GODOT ENGINE                                */
-/*                      https://godotengine.org                          */
-/*************************************************************************/
-/* Copyright (c) 2007-2021 Juan Linietsky, Ariel Manzur.                 */
-/* Copyright (c) 2014-2021 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"
-
-void hb_bmp_create_font_funcs();
-void hb_bmp_free_font_funcs();
-
-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;
-	hb_font_t *hb_handle = nullptr;
-
-	float height = 0.f;
-	float ascent = 0.f;
-	int base_size = 0;
-	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 bitmap_new(float p_height, float p_ascent, int p_base_size) override;
-
-	virtual void bitmap_add_texture(const Ref<Texture> &p_texture) override;
-	virtual void bitmap_add_char(char32_t p_char, int p_texture_idx, const Rect2 &p_rect, const Size2 &p_align, float p_advance) override;
-	virtual void bitmap_add_kerning_pair(char32_t p_A, char32_t p_B, int p_kerning) 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 float get_font_scale(int p_size) const override;
-
-	virtual hb_font_t *get_hb_handle(int p_size) override;
-
-	virtual bool has_char(char32_t p_char) const override;
-	virtual String get_supported_chars() const override;
-
-	virtual Vector2 get_advance(uint32_t p_char, int p_size) const override;
-	Vector2 get_align(uint32_t p_char, int p_size) const;
-	Vector2 get_size(uint32_t p_char, int p_size) const;
-	virtual Vector2 get_kerning(uint32_t p_char, uint32_t p_next, int p_size) const override;
-	virtual uint32_t get_glyph_index(char32_t p_char, char32_t p_variation_selector) const override { return (uint32_t)p_char; };
-
-	virtual Vector2 draw_glyph(RID p_canvas, int p_size, const Vector2 &p_pos, uint32_t p_index, const Color &p_color) const override;
-	virtual Vector2 draw_glyph_outline(RID p_canvas, int p_size, int p_outline_size, const Vector2 &p_pos, uint32_t p_index, const Color &p_color) const override;
-
-	virtual ~BitmapFontDataAdvanced();
-};
-
-#endif // BITMAP_FONT_ADV_H
diff --git a/modules/text_server_adv/dynamic_font_adv.cpp b/modules/text_server_adv/dynamic_font_adv.cpp
deleted file mode 100644
index 62eedebb59..0000000000
--- a/modules/text_server_adv/dynamic_font_adv.cpp
+++ /dev/null
@@ -1,1030 +0,0 @@
-/*************************************************************************/
-/*  dynamic_font_adv.cpp                                                 */
-/*************************************************************************/
-/*                       This file is part of:                           */
-/*                           GODOT ENGINE                                */
-/*                      https://godotengine.org                          */
-/*************************************************************************/
-/* Copyright (c) 2007-2021 Juan Linietsky, Ariel Manzur.                 */
-/* Copyright (c) 2014-2021 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"
-
-#ifdef MODULE_FREETYPE_ENABLED
-
-#include FT_STROKER_H
-#include FT_ADVANCES_H
-#include FT_MULTIPLE_MASTERS_H
-
-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 {
-		if (font_mem == nullptr && font_path != String()) {
-			if (!font_mem_cache.is_empty()) {
-				font_mem = font_mem_cache.ptr();
-				font_mem_size = font_mem_cache.size();
-			} else {
-				FileAccess *f = FileAccess::open(font_path, FileAccess::READ);
-				if (!f) {
-					ERR_FAIL_V_MSG(nullptr, "Cannot open font file '" + font_path + "'.");
-				}
-
-				uint64_t len = f->get_length();
-				font_mem_cache.resize(len);
-				f->get_buffer(font_mem_cache.ptrw(), len);
-				font_mem = font_mem_cache.ptr();
-				font_mem_size = len;
-				f->close();
-			}
-		}
-
-		int error = 0;
-		fds = memnew(DataAtSize);
-		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 = (-FT_MulFix(fds->face->underline_position, fds->face->size->metrics.y_scale) / 64.0) / oversampling * fds->scale_color_font;
-		fds->underline_thickness = (FT_MulFix(fds->face->underline_thickness, fds->face->size->metrics.y_scale) / 64.0) / oversampling * fds->scale_color_font;
-
-		//Load os2 TTF table
-		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;
-		}
-
-		// Write variations.
-		if (fds->face->face_flags & FT_FACE_FLAG_MULTIPLE_MASTERS) {
-			FT_MM_Var *amaster;
-
-			FT_Get_MM_Var(fds->face, &amaster);
-
-			Vector<hb_variation_t> hb_vars;
-			Vector<FT_Fixed> coords;
-			coords.resize(amaster->num_axis);
-
-			FT_Get_Var_Design_Coordinates(fds->face, coords.size(), coords.ptrw());
-
-			for (FT_UInt i = 0; i < amaster->num_axis; i++) {
-				hb_variation_t var;
-
-				// Reset to default.
-				var.tag = amaster->axis[i].tag;
-				var.value = (double)amaster->axis[i].def / 65536.f;
-				coords.write[i] = amaster->axis[i].def;
-
-				if (variations.has(var.tag)) {
-					var.value = variations[var.tag];
-					coords.write[i] = CLAMP(variations[var.tag] * 65536.f, amaster->axis[i].minimum, amaster->axis[i].maximum);
-				}
-
-				hb_vars.push_back(var);
-			}
-
-			FT_Set_Var_Design_Coordinates(fds->face, coords.size(), coords.ptrw());
-			hb_font_set_variations(fds->hb_handle, hb_vars.is_empty() ? nullptr : &hb_vars[0], hb_vars.size());
-
-			FT_Done_MM_Var(library, amaster);
-		}
-	}
-	return fds;
-}
-
-Dictionary DynamicFontDataAdvanced::get_variation_list() const {
-	_THREAD_SAFE_METHOD_
-	DataAtSize *fds = const_cast<DynamicFontDataAdvanced *>(this)->get_data_for_size(base_size);
-	if (fds == nullptr) {
-		return Dictionary();
-	}
-
-	Dictionary ret;
-	// Read variations.
-	if (fds->face->face_flags & FT_FACE_FLAG_MULTIPLE_MASTERS) {
-		FT_MM_Var *amaster;
-
-		FT_Get_MM_Var(fds->face, &amaster);
-
-		for (FT_UInt i = 0; i < amaster->num_axis; i++) {
-			ret[(int32_t)amaster->axis[i].tag] = Vector3i(amaster->axis[i].minimum / 65536, amaster->axis[i].maximum / 65536, amaster->axis[i].def / 65536);
-		}
-
-		FT_Done_MM_Var(library, amaster);
-	}
-	return ret;
-}
-
-void DynamicFontDataAdvanced::set_variation(const String &p_name, double p_value) {
-	_THREAD_SAFE_METHOD_
-	int32_t tag = TS->name_to_tag(p_name);
-	if (!variations.has(tag) || (variations[tag] != p_value)) {
-		variations[tag] = p_value;
-		clear_cache();
-	}
-}
-
-double DynamicFontDataAdvanced::get_variation(const String &p_name) const {
-	_THREAD_SAFE_METHOD_
-	int32_t tag = TS->name_to_tag(p_name);
-	if (!variations.has(tag)) {
-		return 0.f;
-	}
-	return variations[tag];
-}
-
-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, nullptr, nullptr);
-	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, nullptr, nullptr);
-	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;
-
-	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.instantiate();
-				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).round();
-	chr.advance = (advance * p_data->scale_color_font / oversampling).round();
-	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, nullptr, nullptr);
-	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, nullptr, nullptr);
-	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) {
-			Point2i 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, 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) {
-			Point2i 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, false);
-			}
-		}
-
-		advance = ch.advance;
-	}
-
-	return advance;
-}
-
-bool DynamicFontDataAdvanced::get_glyph_contours(int p_size, uint32_t p_index, Vector<Vector3> &r_points, Vector<int32_t> &r_contours, bool &r_orientation) const {
-	_THREAD_SAFE_METHOD_
-	DataAtSize *fds = const_cast<DynamicFontDataAdvanced *>(this)->get_data_for_size(p_size);
-	ERR_FAIL_COND_V(fds == nullptr, false);
-
-	int error = FT_Load_Glyph(fds->face, p_index, FT_LOAD_NO_BITMAP | (force_autohinter ? FT_LOAD_FORCE_AUTOHINT : 0));
-	ERR_FAIL_COND_V(error, false);
-
-	r_points.clear();
-	r_contours.clear();
-
-	float h = fds->ascent;
-	float scale = (1.0 / 64.0) / oversampling * fds->scale_color_font;
-	for (short i = 0; i < fds->face->glyph->outline.n_points; i++) {
-		r_points.push_back(Vector3(fds->face->glyph->outline.points[i].x * scale, h - fds->face->glyph->outline.points[i].y * scale, FT_CURVE_TAG(fds->face->glyph->outline.tags[i])));
-	}
-	for (short i = 0; i < fds->face->glyph->outline.n_contours; i++) {
-		r_contours.push_back(fds->face->glyph->outline.contours[i]);
-	}
-	r_orientation = (FT_Outline_Get_Orientation(&fds->face->glyph->outline) == FT_ORIENTATION_FILL_RIGHT);
-	return true;
-}
-
-DynamicFontDataAdvanced::~DynamicFontDataAdvanced() {
-	clear_cache();
-	if (library != nullptr) {
-		FT_Done_FreeType(library);
-	}
-}
-
-#endif // MODULE_FREETYPE_ENABLED
diff --git a/modules/text_server_adv/dynamic_font_adv.h b/modules/text_server_adv/dynamic_font_adv.h
deleted file mode 100644
index b3f97bb029..0000000000
--- a/modules/text_server_adv/dynamic_font_adv.h
+++ /dev/null
@@ -1,195 +0,0 @@
-/*************************************************************************/
-/*  dynamic_font_adv.h                                                   */
-/*************************************************************************/
-/*                       This file is part of:                           */
-/*                           GODOT ENGINE                                */
-/*                      https://godotengine.org                          */
-/*************************************************************************/
-/* Copyright (c) 2007-2021 Juan Linietsky, Ariel Manzur.                 */
-/* Copyright (c) 2014-2021 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 "modules/modules_enabled.gen.h"
-#ifdef MODULE_FREETYPE_ENABLED
-
-#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 = 0;
-		};
-		bool operator<(CacheID right) const {
-			return key < right.key;
-		}
-	};
-
-	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.0;
-		float descent = 0.0;
-		float underline_position = 0.0;
-		float underline_thickness = 0.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;
-	Vector<uint8_t> font_mem_cache;
-
-	Map<int32_t, double> variations;
-
-	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;
-
-	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 Dictionary get_variation_list() const override;
-
-	virtual void set_variation(const String &p_name, double p_value) override;
-	virtual double get_variation(const String &p_name) 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 bool get_glyph_contours(int p_size, uint32_t p_index, Vector<Vector3> &r_points, Vector<int32_t> &r_contours, bool &r_orientation) const override;
-
-	virtual ~DynamicFontDataAdvanced() override;
-};
-
-#endif // MODULE_FREETYPE_ENABLED
-
-#endif // DYNAMIC_FONT_ADV_H
diff --git a/modules/text_server_adv/font_adv.h b/modules/text_server_adv/font_adv.h
deleted file mode 100644
index 4fadefc569..0000000000
--- a/modules/text_server_adv/font_adv.h
+++ /dev/null
@@ -1,115 +0,0 @@
-/*************************************************************************/
-/*  font_adv.h                                                           */
-/*************************************************************************/
-/*                       This file is part of:                           */
-/*                           GODOT ENGINE                                */
-/*                      https://godotengine.org                          */
-/*************************************************************************/
-/* Copyright (c) 2007-2021 Juan Linietsky, Ariel Manzur.                 */
-/* Copyright (c) 2014-2021 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;
-	int spacing_space = 0;
-	int spacing_glyph = 0;
-
-	virtual void clear_cache() = 0;
-
-	virtual Error load_from_file(const String &p_filename, int p_base_size) { return ERR_CANT_CREATE; };
-	virtual Error load_from_memory(const uint8_t *p_data, size_t p_size, int p_base_size) { return ERR_CANT_CREATE; };
-	virtual Error bitmap_new(float p_height, float p_ascent, int p_base_size) { return ERR_CANT_CREATE; };
-
-	virtual void bitmap_add_texture(const Ref<Texture> &p_texture) { ERR_FAIL_MSG("Not supported."); };
-	virtual void bitmap_add_char(char32_t p_char, int p_texture_idx, const Rect2 &p_rect, const Size2 &p_align, float p_advance) { ERR_FAIL_MSG("Not supported."); };
-	virtual void bitmap_add_kerning_pair(char32_t p_A, char32_t p_B, int p_kerning) { ERR_FAIL_MSG("Not supported."); };
-
-	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 Dictionary get_variation_list() const { return Dictionary(); };
-
-	virtual void set_variation(const String &p_name, double p_value){};
-	virtual double get_variation(const String &p_name) const { return 0; };
-
-	virtual float get_underline_position(int p_size) const = 0;
-	virtual float get_underline_thickness(int p_size) const = 0;
-
-	virtual int get_spacing_space() const { return spacing_space; };
-	virtual void set_spacing_space(int p_value) {
-		spacing_space = p_value;
-		clear_cache();
-	};
-
-	virtual int get_spacing_glyph() const { return spacing_glyph; };
-	virtual void set_spacing_glyph(int p_value) {
-		spacing_glyph = p_value;
-		clear_cache();
-	};
-
-	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 true; };
-	virtual bool is_script_supported(uint32_t p_script) const { return true; };
-
-	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 bool get_glyph_contours(int p_size, uint32_t p_index, Vector<Vector3> &r_points, Vector<int32_t> &r_contours, bool &r_orientation) const { return false; };
-
-	virtual ~FontDataAdvanced(){};
-};
-
-#endif // FONT_ADV_H
diff --git a/modules/text_server_adv/text_server_adv.cpp b/modules/text_server_adv/text_server_adv.cpp
index 9ecb0de5b8..78a87be971 100644
--- a/modules/text_server_adv/text_server_adv.cpp
+++ b/modules/text_server_adv/text_server_adv.cpp
@@ -29,15 +29,213 @@
 /*************************************************************************/
 
 #include "text_server_adv.h"
-#include "bitmap_font_adv.h"
-#include "dynamic_font_adv.h"
 
+#include "core/string/print_string.h"
 #include "core/string/translation.h"
 
 #ifdef ICU_STATIC_DATA
 #include "thirdparty/icu4c/icudata.gen.h"
 #endif
 
+#ifdef MODULE_MSDFGEN_ENABLED
+#include "core/ShapeDistanceFinder.h"
+#include "core/contour-combiners.h"
+#include "core/edge-selectors.h"
+#include "msdfgen.h"
+#endif
+
+/*************************************************************************/
+/*  hb_bmp_font_t HarfBuzz Bitmap font interface                         */
+/*************************************************************************/
+
+hb_font_funcs_t *TextServerAdvanced::funcs = nullptr;
+
+TextServerAdvanced::hb_bmp_font_t *TextServerAdvanced::_hb_bmp_font_create(TextServerAdvanced::FontDataForSizeAdvanced *p_face, bool p_unref) {
+	hb_bmp_font_t *bm_font = memnew(hb_bmp_font_t);
+
+	if (!bm_font) {
+		return nullptr;
+	}
+
+	bm_font->face = p_face;
+	bm_font->unref = p_unref;
+
+	return bm_font;
+}
+
+void TextServerAdvanced::_hb_bmp_font_destroy(void *p_data) {
+	hb_bmp_font_t *bm_font = reinterpret_cast<hb_bmp_font_t *>(p_data);
+	memdelete(bm_font);
+}
+
+hb_bool_t TextServerAdvanced::hb_bmp_get_nominal_glyph(hb_font_t *p_font, void *p_font_data, hb_codepoint_t p_unicode, hb_codepoint_t *r_glyph, void *p_user_data) {
+	const hb_bmp_font_t *bm_font = reinterpret_cast<const hb_bmp_font_t *>(p_font_data);
+
+	if (!bm_font->face) {
+		return false;
+	}
+
+	if (!bm_font->face->glyph_map.has(p_unicode)) {
+		if (bm_font->face->glyph_map.has(0xF000u + p_unicode)) {
+			*r_glyph = 0xF000u + p_unicode;
+			return true;
+		} else {
+			return false;
+		}
+	}
+
+	*r_glyph = p_unicode;
+	return true;
+}
+
+hb_position_t TextServerAdvanced::hb_bmp_get_glyph_h_advance(hb_font_t *p_font, void *p_font_data, hb_codepoint_t p_glyph, void *p_user_data) {
+	const hb_bmp_font_t *bm_font = reinterpret_cast<const hb_bmp_font_t *>(p_font_data);
+
+	if (!bm_font->face) {
+		return 0;
+	}
+
+	if (!bm_font->face->glyph_map.has(p_glyph)) {
+		return 0;
+	}
+
+	return bm_font->face->glyph_map[p_glyph].advance.x * 64;
+}
+
+hb_position_t TextServerAdvanced::hb_bmp_get_glyph_v_advance(hb_font_t *p_font, void *p_font_data, hb_codepoint_t p_glyph, void *p_user_data) {
+	const hb_bmp_font_t *bm_font = reinterpret_cast<const hb_bmp_font_t *>(p_font_data);
+
+	if (!bm_font->face) {
+		return 0;
+	}
+
+	if (!bm_font->face->glyph_map.has(p_glyph)) {
+		return 0;
+	}
+
+	return -bm_font->face->glyph_map[p_glyph].advance.y * 64;
+}
+
+hb_position_t TextServerAdvanced::hb_bmp_get_glyph_h_kerning(hb_font_t *p_font, void *p_font_data, hb_codepoint_t p_left_glyph, hb_codepoint_t p_right_glyph, void *p_user_data) {
+	const hb_bmp_font_t *bm_font = reinterpret_cast<const hb_bmp_font_t *>(p_font_data);
+
+	if (!bm_font->face) {
+		return 0;
+	}
+
+	if (!bm_font->face->kerning_map.has(Vector2i(p_left_glyph, p_right_glyph))) {
+		return 0;
+	}
+
+	return bm_font->face->kerning_map[Vector2i(p_left_glyph, p_right_glyph)].x * 64;
+}
+
+hb_position_t TextServerAdvanced::hb_bmp_get_glyph_v_kerning(hb_font_t *p_font, void *p_font_data, hb_codepoint_t p_left_glyph, hb_codepoint_t p_right_glyph, void *p_user_data) {
+	const hb_bmp_font_t *bm_font = reinterpret_cast<const hb_bmp_font_t *>(p_font_data);
+
+	if (!bm_font->face) {
+		return 0;
+	}
+
+	if (!bm_font->face->kerning_map.has(Vector2i(p_left_glyph, p_right_glyph))) {
+		return 0;
+	}
+
+	return bm_font->face->kerning_map[Vector2i(p_left_glyph, p_right_glyph)].y * 64;
+}
+
+hb_bool_t TextServerAdvanced::hb_bmp_get_glyph_v_origin(hb_font_t *p_font, void *p_font_data, hb_codepoint_t p_glyph, hb_position_t *r_x, hb_position_t *r_y, void *p_user_data) {
+	const hb_bmp_font_t *bm_font = reinterpret_cast<const hb_bmp_font_t *>(p_font_data);
+
+	if (!bm_font->face) {
+		return false;
+	}
+
+	if (!bm_font->face->glyph_map.has(p_glyph)) {
+		return false;
+	}
+
+	*r_x = bm_font->face->glyph_map[p_glyph].advance.x * 32;
+	*r_y = -bm_font->face->ascent * 64;
+
+	return true;
+}
+
+hb_bool_t TextServerAdvanced::hb_bmp_get_glyph_extents(hb_font_t *p_font, void *p_font_data, hb_codepoint_t p_glyph, hb_glyph_extents_t *r_extents, void *p_user_data) {
+	const hb_bmp_font_t *bm_font = reinterpret_cast<const hb_bmp_font_t *>(p_font_data);
+
+	if (!bm_font->face) {
+		return false;
+	}
+
+	if (!bm_font->face->glyph_map.has(p_glyph)) {
+		return false;
+	}
+
+	r_extents->x_bearing = 0;
+	r_extents->y_bearing = 0;
+	r_extents->width = bm_font->face->glyph_map[p_glyph].rect.size.x * 64;
+	r_extents->height = bm_font->face->glyph_map[p_glyph].rect.size.y * 64;
+
+	return true;
+}
+
+hb_bool_t TextServerAdvanced::hb_bmp_get_font_h_extents(hb_font_t *p_font, void *p_font_data, hb_font_extents_t *r_metrics, void *p_user_data) {
+	const hb_bmp_font_t *bm_font = reinterpret_cast<const hb_bmp_font_t *>(p_font_data);
+
+	if (!bm_font->face) {
+		return false;
+	}
+
+	r_metrics->ascender = bm_font->face->ascent;
+	r_metrics->descender = bm_font->face->descent;
+	r_metrics->line_gap = 0;
+
+	return true;
+}
+
+void TextServerAdvanced::hb_bmp_create_font_funcs() {
+	if (funcs == nullptr) {
+		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_nominal_glyph_func(funcs, hb_bmp_get_nominal_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_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_make_immutable(funcs);
+	}
+}
+
+void TextServerAdvanced::hb_bmp_free_font_funcs() {
+	if (funcs != nullptr) {
+		hb_font_funcs_destroy(funcs);
+		funcs = nullptr;
+	}
+}
+
+void TextServerAdvanced::_hb_bmp_font_set_funcs(hb_font_t *p_font, TextServerAdvanced::FontDataForSizeAdvanced *p_face, bool p_unref) {
+	hb_font_set_funcs(p_font, funcs, _hb_bmp_font_create(p_face, p_unref), _hb_bmp_font_destroy);
+}
+
+hb_font_t *TextServerAdvanced::hb_bmp_font_create(TextServerAdvanced::FontDataForSizeAdvanced *p_face, 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, false);
+	return font;
+}
+
+/*************************************************************************/
+/*  Character properties.                                                */
+/*************************************************************************/
+
 _FORCE_INLINE_ bool is_ain(char32_t p_chr) {
 	return u_getIntPropertyValue(p_chr, UCHAR_JOINING_GROUP) == U_JG_AIN;
 }
@@ -497,7 +695,7 @@ static FeatureInfo feature_set[] = {
 	{ 0, String() },
 };
 
-int32_t TextServerAdvanced::name_to_tag(const String &p_name) {
+int32_t TextServerAdvanced::name_to_tag(const String &p_name) const {
 	for (int i = 0; feature_set[i].tag != 0; i++) {
 		if (feature_set[i].name == p_name) {
 			return feature_set[i].tag;
@@ -508,7 +706,7 @@ int32_t TextServerAdvanced::name_to_tag(const String &p_name) {
 	return hb_tag_from_string(p_name.replace("custom_", "").ascii().get_data(), -1);
 }
 
-String TextServerAdvanced::tag_to_name(int32_t p_tag) {
+String TextServerAdvanced::tag_to_name(int32_t p_tag) const {
 	for (int i = 0; feature_set[i].tag != 0; i++) {
 		if (feature_set[i].tag == p_tag) {
 			return feature_set[i].name;
@@ -523,426 +721,2094 @@ String TextServerAdvanced::tag_to_name(int32_t p_tag) {
 }
 
 /*************************************************************************/
-/* Font interface */
+/* Font Glyph Rendering                                                  */
 /*************************************************************************/
 
-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.");
+_FORCE_INLINE_ TextServerAdvanced::FontTexturePosition TextServerAdvanced::find_texture_pos_for_glyph(FontDataForSizeAdvanced *p_data, int p_color_size, Image::Format p_image_format, int p_width, int p_height) const {
+	FontTexturePosition ret;
+	ret.index = -1;
+
+	int mw = p_width;
+	int mh = p_height;
+
+	for (int i = 0; i < p_data->textures.size(); i++) {
+		const FontTexture &ct = p_data->textures[i];
+
+		if (RenderingServer::get_singleton() != nullptr) {
+			if (ct.texture->get_format() != p_image_format) {
+				continue;
+			}
+		}
+
+		if (mw > ct.texture_w || mh > ct.texture_h) { // Too big for this texture.
+			continue;
+		}
+
+		ret.y = 0x7FFFFFFF;
+		ret.x = 0;
+
+		for (int j = 0; j < ct.texture_w - 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_h) {
+			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.x * p_data->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);
+
+		FontTexture tex;
+		tex.texture_w = texsize;
+		tex.texture_h = texsize;
+		tex.format = p_image_format;
+		tex.imgdata.resize(texsize * texsize * p_color_size);
+
+		{
+			// 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, BW font.
+					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, Color font, Multichannel(+True) SDF.
+					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;
 }
 
-RID TextServerAdvanced::create_font_resource(const String &p_filename, int p_base_size) {
-	_THREAD_SAFE_METHOD_
-	FontDataAdvanced *fd = nullptr;
-	if (p_filename.get_extension() == "fnt" || p_filename.get_extension() == "font") {
-		fd = memnew(BitmapFontDataAdvanced);
+#ifdef MODULE_MSDFGEN_ENABLED
+
+struct MSContext {
+	msdfgen::Point2 position;
+	msdfgen::Shape *shape;
+	msdfgen::Contour *contour;
+};
+
+class DistancePixelConversion {
+	double invRange;
+
+public:
+	_FORCE_INLINE_ explicit DistancePixelConversion(double range) :
+			invRange(1 / range) {}
+	_FORCE_INLINE_ void operator()(float *pixels, const msdfgen::MultiAndTrueDistance &distance) const {
+		pixels[0] = float(invRange * distance.r + .5);
+		pixels[1] = float(invRange * distance.g + .5);
+		pixels[2] = float(invRange * distance.b + .5);
+		pixels[3] = float(invRange * distance.a + .5);
+	}
+};
+
+struct MSDFThreadData {
+	msdfgen::Bitmap<float, 4> *output;
+	msdfgen::Shape *shape;
+	msdfgen::Projection *projection;
+	DistancePixelConversion *distancePixelConversion;
+};
+
+static msdfgen::Point2 ft_point2(const FT_Vector &vector) {
+	return msdfgen::Point2(vector.x / 60.0f, vector.y / 60.0f);
+}
+
+static int ft_move_to(const FT_Vector *to, void *user) {
+	MSContext *context = reinterpret_cast<MSContext *>(user);
+	if (!(context->contour && context->contour->edges.empty())) {
+		context->contour = &context->shape->addContour();
+	}
+	context->position = ft_point2(*to);
+	return 0;
+}
+
+static int ft_line_to(const FT_Vector *to, void *user) {
+	MSContext *context = reinterpret_cast<MSContext *>(user);
+	msdfgen::Point2 endpoint = ft_point2(*to);
+	if (endpoint != context->position) {
+		context->contour->addEdge(new msdfgen::LinearSegment(context->position, endpoint));
+		context->position = endpoint;
+	}
+	return 0;
+}
+
+static int ft_conic_to(const FT_Vector *control, const FT_Vector *to, void *user) {
+	MSContext *context = reinterpret_cast<MSContext *>(user);
+	context->contour->addEdge(new msdfgen::QuadraticSegment(context->position, ft_point2(*control), ft_point2(*to)));
+	context->position = ft_point2(*to);
+	return 0;
+}
+
+static int ft_cubic_to(const FT_Vector *control1, const FT_Vector *control2, const FT_Vector *to, void *user) {
+	MSContext *context = reinterpret_cast<MSContext *>(user);
+	context->contour->addEdge(new msdfgen::CubicSegment(context->position, ft_point2(*control1), ft_point2(*control2), ft_point2(*to)));
+	context->position = ft_point2(*to);
+	return 0;
+}
+
+void TextServerAdvanced::_generateMTSDF_threaded(uint32_t y, void *p_td) const {
+	MSDFThreadData *td = (MSDFThreadData *)p_td;
+
+	msdfgen::ShapeDistanceFinder<msdfgen::OverlappingContourCombiner<msdfgen::MultiAndTrueDistanceSelector>> distanceFinder(*td->shape);
+	int row = td->shape->inverseYAxis ? td->output->height() - y - 1 : y;
+	for (int col = 0; col < td->output->width(); ++col) {
+		int x = (y % 2) ? td->output->width() - col - 1 : col;
+		msdfgen::Point2 p = td->projection->unproject(msdfgen::Point2(x + .5, y + .5));
+		msdfgen::MultiAndTrueDistance distance = distanceFinder.distance(p);
+		td->distancePixelConversion->operator()(td->output->operator()(x, row), distance);
+	}
+}
+
+_FORCE_INLINE_ TextServerAdvanced::FontGlyph TextServerAdvanced::rasterize_msdf(FontDataAdvanced *p_font_data, FontDataForSizeAdvanced *p_data, int p_pixel_range, int p_rect_margin, FT_Outline *outline, const Vector2 &advance) const {
+	msdfgen::Shape shape;
+
+	shape.contours.clear();
+	shape.inverseYAxis = false;
+
+	MSContext context = {};
+	context.shape = &shape;
+	FT_Outline_Funcs ft_functions;
+	ft_functions.move_to = &ft_move_to;
+	ft_functions.line_to = &ft_line_to;
+	ft_functions.conic_to = &ft_conic_to;
+	ft_functions.cubic_to = &ft_cubic_to;
+	ft_functions.shift = 0;
+	ft_functions.delta = 0;
+
+	int error = FT_Outline_Decompose(outline, &ft_functions, &context);
+	ERR_FAIL_COND_V_MSG(error, FontGlyph(), "FreeType: Outline decomposition error: '" + String(FT_Error_String(error)) + "'.");
+	if (!shape.contours.empty() && shape.contours.back().edges.empty()) {
+		shape.contours.pop_back();
+	}
+
+	if (FT_Outline_Get_Orientation(outline) == 1) {
+		for (int i = 0; i < (int)shape.contours.size(); ++i) {
+			shape.contours[i].reverse();
+		}
+	}
+
+	shape.inverseYAxis = true;
+	shape.normalize();
+
+	msdfgen::Shape::Bounds bounds = shape.getBounds(p_pixel_range);
+
+	FontGlyph chr;
+	chr.found = true;
+	chr.advance = advance.round();
+
+	if (shape.validate() && shape.contours.size() > 0) {
+		int w = (bounds.r - bounds.l);
+		int h = (bounds.t - bounds.b);
+
+		int mw = w + p_rect_margin * 2;
+		int mh = h + p_rect_margin * 2;
+
+		ERR_FAIL_COND_V(mw > 4096, FontGlyph());
+		ERR_FAIL_COND_V(mh > 4096, FontGlyph());
+
+		FontTexturePosition tex_pos = find_texture_pos_for_glyph(p_data, 4, Image::FORMAT_RGBA8, mw, mh);
+		ERR_FAIL_COND_V(tex_pos.index < 0, FontGlyph());
+		FontTexture &tex = p_data->textures.write[tex_pos.index];
+
+		edgeColoringSimple(shape, 3.0); // Max. angle.
+		msdfgen::Bitmap<float, 4> image(w, h); // Texture size.
+		//msdfgen::generateMTSDF(image, shape, p_pixel_range, 1.0, msdfgen::Vector2(-bounds.l, -bounds.b)); // Range, scale, translation.
+
+		DistancePixelConversion distancePixelConversion(p_pixel_range);
+		msdfgen::Projection projection(msdfgen::Vector2(1.0, 1.0), msdfgen::Vector2(-bounds.l, -bounds.b));
+		msdfgen::MSDFGeneratorConfig config(true, msdfgen::ErrorCorrectionConfig());
+
+		MSDFThreadData td;
+		td.output = &image;
+		td.shape = &shape;
+		td.projection = &projection;
+		td.distancePixelConversion = &distancePixelConversion;
+
+		if (p_font_data->work_pool.get_thread_count() == 0) {
+			p_font_data->work_pool.init();
+		}
+		p_font_data->work_pool.do_work(h, this, &TextServerAdvanced::_generateMTSDF_threaded, &td);
+
+		msdfgen::msdfErrorCorrection(image, shape, projection, p_pixel_range, config);
+
+		{
+			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 + p_rect_margin) * tex.texture_w + j + tex_pos.x + p_rect_margin) * 4;
+					ERR_FAIL_COND_V(ofs >= tex.imgdata.size(), FontGlyph());
+					wr[ofs + 0] = (uint8_t)(CLAMP(image(j, i)[0] * 256.f, 0.f, 255.f));
+					wr[ofs + 1] = (uint8_t)(CLAMP(image(j, i)[1] * 256.f, 0.f, 255.f));
+					wr[ofs + 2] = (uint8_t)(CLAMP(image(j, i)[2] * 256.f, 0.f, 255.f));
+					wr[ofs + 3] = (uint8_t)(CLAMP(image(j, i)[3] * 256.f, 0.f, 255.f));
+					//wr[ofs + 0] = 100;
+					//wr[ofs + 1] = 100;
+					//wr[ofs + 2] = 100;
+					//wr[ofs + 3] = 100;
+				}
+			}
+		}
+
+		// Blit to image and texture.
+		{
+			if (RenderingServer::get_singleton() != nullptr) {
+				Ref<Image> img = memnew(Image(tex.texture_w, tex.texture_h, 0, Image::FORMAT_RGBA8, tex.imgdata));
+				if (tex.texture.is_null()) {
+					tex.texture.instantiate();
+					tex.texture->create_from_image(img);
+				} else {
+					tex.texture->update(img);
+				}
+			}
+		}
+
+		// Update height array.
+		for (int k = tex_pos.x; k < tex_pos.x + mw; k++) {
+			tex.offsets.write[k] = tex_pos.y + mh;
+		}
+
+		chr.texture_idx = tex_pos.index;
+
+		chr.uv_rect = Rect2(tex_pos.x + p_rect_margin, tex_pos.y + p_rect_margin, w, h);
+		chr.rect.position = Vector2(bounds.l, -bounds.t);
+		chr.rect.size = chr.uv_rect.size;
+	}
+	return chr;
+}
+#endif
+
 #ifdef MODULE_FREETYPE_ENABLED
-	} else if (p_filename.get_extension() == "ttf" || p_filename.get_extension() == "otf" || p_filename.get_extension() == "woff") {
-		fd = memnew(DynamicFontDataAdvanced);
+_FORCE_INLINE_ TextServerAdvanced::FontGlyph TextServerAdvanced::rasterize_bitmap(FontDataForSizeAdvanced *p_data, int p_rect_margin, FT_Bitmap bitmap, int yofs, int xofs, const Vector2 &advance) const {
+	int w = bitmap.width;
+	int h = bitmap.rows;
+
+	int mw = w + p_rect_margin * 2;
+	int mh = h + p_rect_margin * 2;
+
+	ERR_FAIL_COND_V(mw > 4096, FontGlyph());
+	ERR_FAIL_COND_V(mh > 4096, FontGlyph());
+
+	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;
+
+	FontTexturePosition tex_pos = find_texture_pos_for_glyph(p_data, color_size, require_format, mw, mh);
+	ERR_FAIL_COND_V(tex_pos.index < 0, FontGlyph());
+
+	// Fit character in char texture.
+
+	FontTexture &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 + p_rect_margin) * tex.texture_w + j + tex_pos.x + p_rect_margin) * color_size;
+				ERR_FAIL_COND_V(ofs >= tex.imgdata.size(), FontGlyph());
+				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];
+						//wr[ofs + 1] = 100;
+						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;
+					default:
+						ERR_FAIL_V_MSG(FontGlyph(), "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_w, tex.texture_h, 0, require_format, tex.imgdata));
+
+			if (tex.texture.is_null()) {
+				tex.texture.instantiate();
+				tex.texture->create_from_image(img);
+			} else {
+				tex.texture->update(img);
+			}
+		}
+	}
+
+	// Update height array.
+	for (int k = tex_pos.x; k < tex_pos.x + mw; k++) {
+		tex.offsets.write[k] = tex_pos.y + mh;
+	}
+
+	FontGlyph chr;
+	chr.advance = (advance * p_data->scale / p_data->oversampling).round();
+	chr.texture_idx = tex_pos.index;
+	chr.found = true;
+
+	chr.uv_rect = Rect2(tex_pos.x + p_rect_margin, tex_pos.y + p_rect_margin, w, h);
+	chr.rect.position = (Vector2(xofs, -yofs) * p_data->scale / p_data->oversampling).round();
+	chr.rect.size = chr.uv_rect.size * p_data->scale / p_data->oversampling;
+	return chr;
+}
 #endif
-	} else {
-		return RID();
+
+/*************************************************************************/
+/* Font Cache                                                            */
+/*************************************************************************/
+
+_FORCE_INLINE_ bool TextServerAdvanced::_ensure_glyph(FontDataAdvanced *p_font_data, const Vector2i &p_size, int32_t p_glyph) const {
+	ERR_FAIL_COND_V(!_ensure_cache_for_size(p_font_data, p_size), false);
+
+	FontDataForSizeAdvanced *fd = p_font_data->cache[p_size];
+	if (fd->glyph_map.has(p_glyph)) {
+		return fd->glyph_map[p_glyph].found;
 	}
 
-	Error err = fd->load_from_file(p_filename, p_base_size);
-	if (err != OK) {
-		memdelete(fd);
-		return RID();
+	if (p_glyph == 0) { // Non graphical or invalid glyph, do not render.
+		fd->glyph_map[p_glyph] = FontGlyph();
+		return true;
 	}
 
-	return font_owner.make_rid(fd);
+#ifdef MODULE_FREETYPE_ENABLED
+	FontGlyph gl;
+	if (fd->face) {
+		FT_Int32 flags = FT_LOAD_DEFAULT;
+
+		bool outline = p_size.y > 0;
+		switch (p_font_data->hinting) {
+			case TextServer::HINTING_NONE:
+				flags |= FT_LOAD_NO_HINTING;
+				break;
+			case TextServer::HINTING_LIGHT:
+				flags |= FT_LOAD_TARGET_LIGHT;
+				break;
+			default:
+				flags |= FT_LOAD_TARGET_NORMAL;
+				break;
+		}
+		if (p_font_data->force_autohinter) {
+			flags |= FT_LOAD_FORCE_AUTOHINT;
+		}
+		if (outline) {
+			flags |= FT_LOAD_NO_BITMAP;
+		} else if (FT_HAS_COLOR(fd->face)) {
+			flags |= FT_LOAD_COLOR;
+		}
+
+		FT_Fixed v, h;
+		FT_Get_Advance(fd->face, p_glyph, flags, &h);
+		FT_Get_Advance(fd->face, p_glyph, flags | FT_LOAD_VERTICAL_LAYOUT, &v);
+
+		int error = FT_Load_Glyph(fd->face, p_glyph, flags);
+		if (error) {
+			fd->glyph_map[p_glyph] = FontGlyph();
+			ERR_FAIL_V_MSG(false, "FreeType: Failed to load glyph.");
+		}
+
+		if (!outline) {
+			if (!p_font_data->msdf) {
+				error = FT_Render_Glyph(fd->face->glyph, p_font_data->antialiased ? FT_RENDER_MODE_NORMAL : FT_RENDER_MODE_MONO);
+			}
+			FT_GlyphSlot slot = fd->face->glyph;
+			if (!error) {
+				if (p_font_data->msdf) {
+#ifdef MODULE_MSDFGEN_ENABLED
+					gl = rasterize_msdf(p_font_data, fd, p_font_data->msdf_range, rect_range, &slot->outline, Vector2((h + (1 << 9)) >> 10, (v + (1 << 9)) >> 10) / 64.0);
+#else
+					fd->glyph_map[p_glyph] = FontGlyph();
+					ERR_FAIL_V_MSG(false, "Compiled without MSDFGEN support!");
+#endif
+				} else {
+					gl = rasterize_bitmap(fd, rect_range, slot->bitmap, slot->bitmap_top, slot->bitmap_left, Vector2((h + (1 << 9)) >> 10, (v + (1 << 9)) >> 10) / 64.0);
+				}
+			}
+		} else {
+			FT_Stroker stroker;
+			if (FT_Stroker_New(library, &stroker) != 0) {
+				fd->glyph_map[p_glyph] = FontGlyph();
+				ERR_FAIL_V_MSG(false, "FreeType: Failed to load glyph stroker.");
+			}
+
+			FT_Stroker_Set(stroker, (int)(fd->size.y * fd->oversampling * 16.0), FT_STROKER_LINECAP_BUTT, FT_STROKER_LINEJOIN_ROUND, 0);
+			FT_Glyph glyph;
+			FT_BitmapGlyph glyph_bitmap;
+
+			if (FT_Get_Glyph(fd->face->glyph, &glyph) != 0) {
+				goto cleanup_stroker;
+			}
+			if (FT_Glyph_Stroke(&glyph, stroker, 1) != 0) {
+				goto cleanup_glyph;
+			}
+			if (FT_Glyph_To_Bitmap(&glyph, p_font_data->antialiased ? FT_RENDER_MODE_NORMAL : FT_RENDER_MODE_MONO, nullptr, 1) != 0) {
+				goto cleanup_glyph;
+			}
+			glyph_bitmap = (FT_BitmapGlyph)glyph;
+			gl = rasterize_bitmap(fd, rect_range, glyph_bitmap->bitmap, glyph_bitmap->top, glyph_bitmap->left, Vector2());
+
+		cleanup_glyph:
+			FT_Done_Glyph(glyph);
+		cleanup_stroker:
+			FT_Stroker_Done(stroker);
+		}
+		fd->glyph_map[p_glyph] = gl;
+		return gl.found;
+	}
+#endif
+	fd->glyph_map[p_glyph] = FontGlyph();
+	return false;
 }
 
-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 == "fnt" || p_type == "font") {
-		fd = memnew(BitmapFontDataAdvanced);
+_FORCE_INLINE_ bool TextServerAdvanced::_ensure_cache_for_size(FontDataAdvanced *p_font_data, const Vector2i &p_size) const {
+	if (p_font_data->cache.has(p_size)) {
+		return true;
+	}
+
+	FontDataForSizeAdvanced *fd = memnew(FontDataForSizeAdvanced);
+	fd->size = p_size;
+	if (p_font_data->data_ptr) {
+		// Init dynamic font.
 #ifdef MODULE_FREETYPE_ENABLED
-	} else if (p_type == "ttf" || p_type == "otf" || p_type == "woff") {
-		fd = memnew(DynamicFontDataAdvanced);
+		int error = 0;
+		if (!library) {
+			error = FT_Init_FreeType(&library);
+			ERR_FAIL_COND_V_MSG(error != 0, false, TTR("FreeType: Error initializing library:") + " '" + String(FT_Error_String(error)) + "'.");
+		}
+
+		memset(&fd->stream, 0, sizeof(FT_StreamRec));
+		fd->stream.base = (unsigned char *)p_font_data->data_ptr;
+		fd->stream.size = p_font_data->data_size;
+		fd->stream.pos = 0;
+
+		FT_Open_Args fargs;
+		memset(&fargs, 0, sizeof(FT_Open_Args));
+		fargs.memory_base = (unsigned char *)p_font_data->data_ptr;
+		fargs.memory_size = p_font_data->data_size;
+		fargs.flags = FT_OPEN_MEMORY;
+		fargs.stream = &fd->stream;
+		error = FT_Open_Face(library, &fargs, 0, &fd->face);
+		if (error) {
+			FT_Done_Face(fd->face);
+			fd->face = nullptr;
+			ERR_FAIL_V_MSG(false, TTR("FreeType: Error loading font:") + " '" + String(FT_Error_String(error)) + "'.");
+		}
+		fd->hb_handle = hb_ft_font_create(fd->face, nullptr);
+		if (fd->hb_handle == nullptr) {
+			FT_Done_Face(fd->face);
+			fd->face = nullptr;
+			ERR_FAIL_V_MSG(false, TTR("HarfBuzz: Error creating FreeType font object."));
+		}
+
+		if (p_font_data->msdf) {
+			fd->oversampling = 1.0f;
+			fd->size.x = p_font_data->msdf_source_size;
+		} else if (p_font_data->oversampling <= 0.0f) {
+			fd->oversampling = TS->font_get_global_oversampling();
+		} else {
+			fd->oversampling = p_font_data->oversampling;
+		}
+
+		if (FT_HAS_COLOR(fd->face) && fd->face->num_fixed_sizes > 0) {
+			int best_match = 0;
+			int diff = ABS(fd->size.x - ((int64_t)fd->face->available_sizes[0].width));
+			fd->scale = real_t(fd->size.x * fd->oversampling) / fd->face->available_sizes[0].width;
+			for (int i = 1; i < fd->face->num_fixed_sizes; i++) {
+				int ndiff = ABS(fd->size.x - ((int64_t)fd->face->available_sizes[i].width));
+				if (ndiff < diff) {
+					best_match = i;
+					diff = ndiff;
+					fd->scale = real_t(fd->size.x * fd->oversampling) / fd->face->available_sizes[i].width;
+				}
+			}
+			FT_Select_Size(fd->face, best_match);
+		} else {
+			FT_Set_Pixel_Sizes(fd->face, 0, fd->size.x * fd->oversampling);
+		}
+
+		fd->ascent = (fd->face->size->metrics.ascender / 64.0) / fd->oversampling * fd->scale;
+		fd->descent = (-fd->face->size->metrics.descender / 64.0) / fd->oversampling * fd->scale;
+		fd->underline_position = (-FT_MulFix(fd->face->underline_position, fd->face->size->metrics.y_scale) / 64.0) / fd->oversampling * fd->scale;
+		fd->underline_thickness = (FT_MulFix(fd->face->underline_thickness, fd->face->size->metrics.y_scale) / 64.0) / fd->oversampling * fd->scale;
+
+		if (!p_font_data->face_init) {
+			// Get supported scripts from OpenType font data.
+			p_font_data->supported_scripts.clear();
+			unsigned int count = hb_ot_layout_table_get_script_tags(hb_font_get_face(fd->hb_handle), HB_OT_TAG_GSUB, 0, nullptr, nullptr);
+			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(fd->hb_handle), HB_OT_TAG_GSUB, 0, &count, script_tags);
+				for (unsigned int i = 0; i < count; i++) {
+					p_font_data->supported_scripts.insert(script_tags[i]);
+				}
+				memfree(script_tags);
+			}
+			count = hb_ot_layout_table_get_script_tags(hb_font_get_face(fd->hb_handle), HB_OT_TAG_GPOS, 0, nullptr, nullptr);
+			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(fd->hb_handle), HB_OT_TAG_GPOS, 0, &count, script_tags);
+				for (unsigned int i = 0; i < count; i++) {
+					p_font_data->supported_scripts.insert(script_tags[i]);
+				}
+				memfree(script_tags);
+			}
+
+			// Get supported scripts from OS2 table.
+			TT_OS2 *os2 = (TT_OS2 *)FT_Get_Sfnt_Table(fd->face, FT_SFNT_OS2);
+			if (os2) {
+				if ((os2->ulUnicodeRange1 & 1L << 4) || (os2->ulUnicodeRange1 & 1L << 5) || (os2->ulUnicodeRange1 & 1L << 6) || (os2->ulUnicodeRange1 & 1L << 31) || (os2->ulUnicodeRange2 & 1L << 0) || (os2->ulUnicodeRange2 & 1L << 1) || (os2->ulUnicodeRange2 & 1L << 2) || (os2->ulUnicodeRange2 & 1L << 3) || (os2->ulUnicodeRange2 & 1L << 4) || (os2->ulUnicodeRange2 & 1L << 5) || (os2->ulUnicodeRange2 & 1L << 6) || (os2->ulUnicodeRange2 & 1L << 7) || (os2->ulUnicodeRange2 & 1L << 8) || (os2->ulUnicodeRange2 & 1L << 9) || (os2->ulUnicodeRange2 & 1L << 10) || (os2->ulUnicodeRange2 & 1L << 11) || (os2->ulUnicodeRange2 & 1L << 12) || (os2->ulUnicodeRange2 & 1L << 13) || (os2->ulUnicodeRange2 & 1L << 14) || (os2->ulUnicodeRange2 & 1L << 15) || (os2->ulUnicodeRange2 & 1L << 30) || (os2->ulUnicodeRange3 & 1L << 0) || (os2->ulUnicodeRange3 & 1L << 1) || (os2->ulUnicodeRange3 & 1L << 2) || (os2->ulUnicodeRange3 & 1L << 4) || (os2->ulUnicodeRange3 & 1L << 5) || (os2->ulUnicodeRange3 & 1L << 18) || (os2->ulUnicodeRange3 & 1L << 24) || (os2->ulUnicodeRange3 & 1L << 25) || (os2->ulUnicodeRange3 & 1L << 26) || (os2->ulUnicodeRange3 & 1L << 27) || (os2->ulUnicodeRange3 & 1L << 28) || (os2->ulUnicodeRange4 & 1L << 3) || (os2->ulUnicodeRange4 & 1L << 6) || (os2->ulUnicodeRange4 & 1L << 15) || (os2->ulUnicodeRange4 & 1L << 23) || (os2->ulUnicodeRange4 & 1L << 24) || (os2->ulUnicodeRange4 & 1L << 26)) {
+					p_font_data->supported_scripts.insert(HB_SCRIPT_COMMON);
+				}
+				if ((os2->ulUnicodeRange1 & 1L << 0) || (os2->ulUnicodeRange1 & 1L << 1) || (os2->ulUnicodeRange1 & 1L << 2) || (os2->ulUnicodeRange1 & 1L << 3) || (os2->ulUnicodeRange1 & 1L << 29)) {
+					p_font_data->supported_scripts.insert(HB_SCRIPT_LATIN);
+				}
+				if ((os2->ulUnicodeRange1 & 1L << 7) || (os2->ulUnicodeRange1 & 1L << 30)) {
+					p_font_data->supported_scripts.insert(HB_SCRIPT_GREEK);
+				}
+				if (os2->ulUnicodeRange1 & 1L << 8) {
+					p_font_data->supported_scripts.insert(HB_SCRIPT_COPTIC);
+				}
+				if (os2->ulUnicodeRange1 & 1L << 9) {
+					p_font_data->supported_scripts.insert(HB_SCRIPT_CYRILLIC);
+				}
+				if (os2->ulUnicodeRange1 & 1L << 10) {
+					p_font_data->supported_scripts.insert(HB_SCRIPT_ARMENIAN);
+				}
+				if (os2->ulUnicodeRange1 & 1L << 11) {
+					p_font_data->supported_scripts.insert(HB_SCRIPT_HEBREW);
+				}
+				if (os2->ulUnicodeRange1 & 1L << 12) {
+					p_font_data->supported_scripts.insert(HB_SCRIPT_VAI);
+				}
+				if ((os2->ulUnicodeRange1 & 1L << 13) || (os2->ulUnicodeRange2 & 1L << 31) || (os2->ulUnicodeRange3 & 1L << 3)) {
+					p_font_data->supported_scripts.insert(HB_SCRIPT_ARABIC);
+				}
+				if (os2->ulUnicodeRange1 & 1L << 14) {
+					p_font_data->supported_scripts.insert(HB_SCRIPT_NKO);
+				}
+				if (os2->ulUnicodeRange1 & 1L << 15) {
+					p_font_data->supported_scripts.insert(HB_SCRIPT_DEVANAGARI);
+				}
+				if (os2->ulUnicodeRange1 & 1L << 16) {
+					p_font_data->supported_scripts.insert(HB_SCRIPT_BENGALI);
+				}
+				if (os2->ulUnicodeRange1 & 1L << 17) {
+					p_font_data->supported_scripts.insert(HB_SCRIPT_GURMUKHI);
+				}
+				if (os2->ulUnicodeRange1 & 1L << 18) {
+					p_font_data->supported_scripts.insert(HB_SCRIPT_GUJARATI);
+				}
+				if (os2->ulUnicodeRange1 & 1L << 19) {
+					p_font_data->supported_scripts.insert(HB_SCRIPT_ORIYA);
+				}
+				if (os2->ulUnicodeRange1 & 1L << 20) {
+					p_font_data->supported_scripts.insert(HB_SCRIPT_TAMIL);
+				}
+				if (os2->ulUnicodeRange1 & 1L << 21) {
+					p_font_data->supported_scripts.insert(HB_SCRIPT_TELUGU);
+				}
+				if (os2->ulUnicodeRange1 & 1L << 22) {
+					p_font_data->supported_scripts.insert(HB_SCRIPT_KANNADA);
+				}
+				if (os2->ulUnicodeRange1 & 1L << 23) {
+					p_font_data->supported_scripts.insert(HB_SCRIPT_MALAYALAM);
+				}
+				if (os2->ulUnicodeRange1 & 1L << 24) {
+					p_font_data->supported_scripts.insert(HB_SCRIPT_THAI);
+				}
+				if (os2->ulUnicodeRange1 & 1L << 25) {
+					p_font_data->supported_scripts.insert(HB_SCRIPT_LAO);
+				}
+				if (os2->ulUnicodeRange1 & 1L << 26) {
+					p_font_data->supported_scripts.insert(HB_SCRIPT_GEORGIAN);
+				}
+				if (os2->ulUnicodeRange1 & 1L << 27) {
+					p_font_data->supported_scripts.insert(HB_SCRIPT_BALINESE);
+				}
+				if ((os2->ulUnicodeRange1 & 1L << 28) || (os2->ulUnicodeRange2 & 1L << 20) || (os2->ulUnicodeRange2 & 1L << 24)) {
+					p_font_data->supported_scripts.insert(HB_SCRIPT_HANGUL);
+				}
+				if ((os2->ulUnicodeRange2 & 1L << 21) || (os2->ulUnicodeRange2 & 1L << 22) || (os2->ulUnicodeRange2 & 1L << 23) || (os2->ulUnicodeRange2 & 1L << 26) || (os2->ulUnicodeRange2 & 1L << 27) || (os2->ulUnicodeRange2 & 1L << 29)) {
+					p_font_data->supported_scripts.insert(HB_SCRIPT_HAN);
+				}
+				if (os2->ulUnicodeRange2 & 1L << 17) {
+					p_font_data->supported_scripts.insert(HB_SCRIPT_HIRAGANA);
+				}
+				if (os2->ulUnicodeRange2 & 1L << 18) {
+					p_font_data->supported_scripts.insert(HB_SCRIPT_KATAKANA);
+				}
+				if (os2->ulUnicodeRange2 & 1L << 19) {
+					p_font_data->supported_scripts.insert(HB_SCRIPT_BOPOMOFO);
+				}
+				if (os2->ulUnicodeRange3 & 1L << 6) {
+					p_font_data->supported_scripts.insert(HB_SCRIPT_TIBETAN);
+				}
+				if (os2->ulUnicodeRange3 & 1L << 7) {
+					p_font_data->supported_scripts.insert(HB_SCRIPT_SYRIAC);
+				}
+				if (os2->ulUnicodeRange3 & 1L << 8) {
+					p_font_data->supported_scripts.insert(HB_SCRIPT_THAANA);
+				}
+				if (os2->ulUnicodeRange3 & 1L << 9) {
+					p_font_data->supported_scripts.insert(HB_SCRIPT_SINHALA);
+				}
+				if (os2->ulUnicodeRange3 & 1L << 10) {
+					p_font_data->supported_scripts.insert(HB_SCRIPT_MYANMAR);
+				}
+				if (os2->ulUnicodeRange3 & 1L << 11) {
+					p_font_data->supported_scripts.insert(HB_SCRIPT_ETHIOPIC);
+				}
+				if (os2->ulUnicodeRange3 & 1L << 12) {
+					p_font_data->supported_scripts.insert(HB_SCRIPT_CHEROKEE);
+				}
+				if (os2->ulUnicodeRange3 & 1L << 13) {
+					p_font_data->supported_scripts.insert(HB_SCRIPT_CANADIAN_SYLLABICS);
+				}
+				if (os2->ulUnicodeRange3 & 1L << 14) {
+					p_font_data->supported_scripts.insert(HB_SCRIPT_OGHAM);
+				}
+				if (os2->ulUnicodeRange3 & 1L << 15) {
+					p_font_data->supported_scripts.insert(HB_SCRIPT_RUNIC);
+				}
+				if (os2->ulUnicodeRange3 & 1L << 16) {
+					p_font_data->supported_scripts.insert(HB_SCRIPT_KHMER);
+				}
+				if (os2->ulUnicodeRange3 & 1L << 17) {
+					p_font_data->supported_scripts.insert(HB_SCRIPT_MONGOLIAN);
+				}
+				if (os2->ulUnicodeRange3 & 1L << 19) {
+					p_font_data->supported_scripts.insert(HB_SCRIPT_YI);
+				}
+				if (os2->ulUnicodeRange3 & 1L << 20) {
+					p_font_data->supported_scripts.insert(HB_SCRIPT_HANUNOO);
+					p_font_data->supported_scripts.insert(HB_SCRIPT_TAGBANWA);
+					p_font_data->supported_scripts.insert(HB_SCRIPT_BUHID);
+					p_font_data->supported_scripts.insert(HB_SCRIPT_TAGALOG);
+				}
+				if (os2->ulUnicodeRange3 & 1L << 21) {
+					p_font_data->supported_scripts.insert(HB_SCRIPT_OLD_ITALIC);
+				}
+				if (os2->ulUnicodeRange3 & 1L << 22) {
+					p_font_data->supported_scripts.insert(HB_SCRIPT_GOTHIC);
+				}
+				if (os2->ulUnicodeRange3 & 1L << 23) {
+					p_font_data->supported_scripts.insert(HB_SCRIPT_DESERET);
+				}
+				if (os2->ulUnicodeRange3 & 1L << 29) {
+					p_font_data->supported_scripts.insert(HB_SCRIPT_LIMBU);
+				}
+				if (os2->ulUnicodeRange3 & 1L << 30) {
+					p_font_data->supported_scripts.insert(HB_SCRIPT_TAI_LE);
+				}
+				if (os2->ulUnicodeRange3 & 1L << 31) {
+					p_font_data->supported_scripts.insert(HB_SCRIPT_NEW_TAI_LUE);
+				}
+				if (os2->ulUnicodeRange4 & 1L << 0) {
+					p_font_data->supported_scripts.insert(HB_SCRIPT_BUGINESE);
+				}
+				if (os2->ulUnicodeRange4 & 1L << 1) {
+					p_font_data->supported_scripts.insert(HB_SCRIPT_GLAGOLITIC);
+				}
+				if (os2->ulUnicodeRange4 & 1L << 2) {
+					p_font_data->supported_scripts.insert(HB_SCRIPT_TIFINAGH);
+				}
+				if (os2->ulUnicodeRange4 & 1L << 4) {
+					p_font_data->supported_scripts.insert(HB_SCRIPT_SYLOTI_NAGRI);
+				}
+				if (os2->ulUnicodeRange4 & 1L << 5) {
+					p_font_data->supported_scripts.insert(HB_SCRIPT_LINEAR_B);
+				}
+				if (os2->ulUnicodeRange4 & 1L << 7) {
+					p_font_data->supported_scripts.insert(HB_SCRIPT_UGARITIC);
+				}
+				if (os2->ulUnicodeRange4 & 1L << 8) {
+					p_font_data->supported_scripts.insert(HB_SCRIPT_OLD_PERSIAN);
+				}
+				if (os2->ulUnicodeRange4 & 1L << 9) {
+					p_font_data->supported_scripts.insert(HB_SCRIPT_SHAVIAN);
+				}
+				if (os2->ulUnicodeRange4 & 1L << 10) {
+					p_font_data->supported_scripts.insert(HB_SCRIPT_OSMANYA);
+				}
+				if (os2->ulUnicodeRange4 & 1L << 11) {
+					p_font_data->supported_scripts.insert(HB_SCRIPT_CYPRIOT);
+				}
+				if (os2->ulUnicodeRange4 & 1L << 12) {
+					p_font_data->supported_scripts.insert(HB_SCRIPT_KHAROSHTHI);
+				}
+				if (os2->ulUnicodeRange4 & 1L << 13) {
+					p_font_data->supported_scripts.insert(HB_SCRIPT_TAI_VIET);
+				}
+				if (os2->ulUnicodeRange4 & 1L << 14) {
+					p_font_data->supported_scripts.insert(HB_SCRIPT_CUNEIFORM);
+				}
+				if (os2->ulUnicodeRange4 & 1L << 16) {
+					p_font_data->supported_scripts.insert(HB_SCRIPT_SUNDANESE);
+				}
+				if (os2->ulUnicodeRange4 & 1L << 17) {
+					p_font_data->supported_scripts.insert(HB_SCRIPT_LEPCHA);
+				}
+				if (os2->ulUnicodeRange4 & 1L << 18) {
+					p_font_data->supported_scripts.insert(HB_SCRIPT_OL_CHIKI);
+				}
+				if (os2->ulUnicodeRange4 & 1L << 19) {
+					p_font_data->supported_scripts.insert(HB_SCRIPT_SAURASHTRA);
+				}
+				if (os2->ulUnicodeRange4 & 1L << 20) {
+					p_font_data->supported_scripts.insert(HB_SCRIPT_KAYAH_LI);
+				}
+				if (os2->ulUnicodeRange4 & 1L << 21) {
+					p_font_data->supported_scripts.insert(HB_SCRIPT_REJANG);
+				}
+				if (os2->ulUnicodeRange4 & 1L << 22) {
+					p_font_data->supported_scripts.insert(HB_SCRIPT_CHAM);
+				}
+				if (os2->ulUnicodeRange4 & 1L << 25) {
+					p_font_data->supported_scripts.insert(HB_SCRIPT_ANATOLIAN_HIEROGLYPHS);
+				}
+			}
+
+			// Read OpenType feature tags.
+			p_font_data->supported_features.clear();
+			count = hb_ot_layout_table_get_feature_tags(hb_font_get_face(fd->hb_handle), HB_OT_TAG_GSUB, 0, nullptr, nullptr);
+			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(fd->hb_handle), HB_OT_TAG_GSUB, 0, &count, feature_tags);
+				for (unsigned int i = 0; i < count; i++) {
+					p_font_data->supported_features[feature_tags[i]] = 1;
+				}
+				memfree(feature_tags);
+			}
+			count = hb_ot_layout_table_get_feature_tags(hb_font_get_face(fd->hb_handle), HB_OT_TAG_GPOS, 0, nullptr, nullptr);
+			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(fd->hb_handle), HB_OT_TAG_GPOS, 0, &count, feature_tags);
+				for (unsigned int i = 0; i < count; i++) {
+					p_font_data->supported_features[feature_tags[i]] = 1;
+				}
+				memfree(feature_tags);
+			}
+
+			// Read OpenType variations.
+			p_font_data->supported_varaitions.clear();
+			if (fd->face->face_flags & FT_FACE_FLAG_MULTIPLE_MASTERS) {
+				FT_MM_Var *amaster;
+				FT_Get_MM_Var(fd->face, &amaster);
+				for (FT_UInt i = 0; i < amaster->num_axis; i++) {
+					p_font_data->supported_varaitions[(int32_t)amaster->axis[i].tag] = Vector3i(amaster->axis[i].minimum / 65536, amaster->axis[i].maximum / 65536, amaster->axis[i].def / 65536);
+				}
+				FT_Done_MM_Var(library, amaster);
+			}
+			p_font_data->face_init = true;
+		}
+
+		// Write variations.
+		if (fd->face->face_flags & FT_FACE_FLAG_MULTIPLE_MASTERS) {
+			FT_MM_Var *amaster;
+
+			FT_Get_MM_Var(fd->face, &amaster);
+
+			Vector<hb_variation_t> hb_vars;
+			Vector<FT_Fixed> coords;
+			coords.resize(amaster->num_axis);
+
+			FT_Get_Var_Design_Coordinates(fd->face, coords.size(), coords.ptrw());
+
+			for (FT_UInt i = 0; i < amaster->num_axis; i++) {
+				hb_variation_t var;
+
+				// Reset to default.
+				var.tag = amaster->axis[i].tag;
+				var.value = (double)amaster->axis[i].def / 65536.f;
+				coords.write[i] = amaster->axis[i].def;
+
+				if (p_font_data->variation_coordinates.has(var.tag)) {
+					var.value = p_font_data->variation_coordinates[var.tag];
+					coords.write[i] = CLAMP(var.value * 65536.f, amaster->axis[i].minimum, amaster->axis[i].maximum);
+				}
+
+				if (p_font_data->variation_coordinates.has(tag_to_name(var.tag))) {
+					var.value = p_font_data->variation_coordinates[tag_to_name(var.tag)];
+					coords.write[i] = CLAMP(var.value * 65536.f, amaster->axis[i].minimum, amaster->axis[i].maximum);
+				}
+
+				hb_vars.push_back(var);
+			}
+
+			FT_Set_Var_Design_Coordinates(fd->face, coords.size(), coords.ptrw());
+			hb_font_set_variations(fd->hb_handle, hb_vars.is_empty() ? nullptr : &hb_vars[0], hb_vars.size());
+			FT_Done_MM_Var(library, amaster);
+		}
+#else
+		ERR_FAIL_V_MSG(false, TTR("FreeType: Can't load dynamic font, engine is compiled without FreeType support!");
 #endif
 	} else {
-		return RID();
+		// Init bitmap font.
+		fd->hb_handle = hb_bmp_font_create(fd, nullptr);
+		if (!fd->hb_handle) {
+			ERR_FAIL_V_MSG(false, TTR("HarfBuzz: Error creating bitmap font object."));
+		}
 	}
+	p_font_data->cache[p_size] = fd;
+	return true;
+}
 
-	Error err = fd->load_from_memory(p_data, p_size, p_base_size);
-	if (err != OK) {
-		memdelete(fd);
-		return RID();
+_FORCE_INLINE_ void TextServerAdvanced::_font_clear_cache(FontDataAdvanced *p_font_data) {
+	for (const Map<Vector2i, FontDataForSizeAdvanced *>::Element *E = p_font_data->cache.front(); E; E = E->next()) {
+		memdelete(E->get());
 	}
+	p_font_data->cache.clear();
+	p_font_data->face_init = false;
+	p_font_data->supported_features.clear();
+	p_font_data->supported_varaitions.clear();
+	p_font_data->supported_scripts.clear();
+}
+
+hb_font_t *TextServerAdvanced::_font_get_hb_handle(RID p_font_rid, int p_size) const {
+	FontDataAdvanced *fd = font_owner.getornull(p_font_rid);
+	ERR_FAIL_COND_V(!fd, nullptr);
+
+	MutexLock lock(fd->mutex);
+	Vector2i size = _get_size(fd, p_size);
+
+	ERR_FAIL_COND_V(!_ensure_cache_for_size(fd, size), nullptr);
+
+	return fd->cache[size]->hb_handle;
+}
+
+RID TextServerAdvanced::create_font() {
+	FontDataAdvanced *fd = memnew(FontDataAdvanced);
 
 	return font_owner.make_rid(fd);
 }
 
-RID TextServerAdvanced::create_font_bitmap(float p_height, float p_ascent, int p_base_size) {
-	_THREAD_SAFE_METHOD_
-	FontDataAdvanced *fd = memnew(BitmapFontDataAdvanced);
-	Error err = fd->bitmap_new(p_height, p_ascent, p_base_size);
-	if (err != OK) {
-		memdelete(fd);
-		return RID();
+void TextServerAdvanced::font_set_data(RID p_font_rid, const PackedByteArray &p_data) {
+	FontDataAdvanced *fd = font_owner.getornull(p_font_rid);
+	ERR_FAIL_COND(!fd);
+
+	MutexLock lock(fd->mutex);
+	_font_clear_cache(fd);
+	fd->data = p_data;
+	fd->data_ptr = fd->data.ptr();
+	fd->data_size = fd->data.size();
+}
+
+void TextServerAdvanced::font_set_data_ptr(RID p_font_rid, const uint8_t *p_data_ptr, size_t p_data_size) {
+	FontDataAdvanced *fd = font_owner.getornull(p_font_rid);
+	ERR_FAIL_COND(!fd);
+
+	MutexLock lock(fd->mutex);
+	_font_clear_cache(fd);
+	fd->data.clear();
+	fd->data_ptr = p_data_ptr;
+	fd->data_size = p_data_size;
+}
+
+void TextServerAdvanced::font_set_antialiased(RID p_font_rid, bool p_antialiased) {
+	FontDataAdvanced *fd = font_owner.getornull(p_font_rid);
+	ERR_FAIL_COND(!fd);
+
+	MutexLock lock(fd->mutex);
+	if (fd->antialiased != p_antialiased) {
+		_font_clear_cache(fd);
+		fd->antialiased = p_antialiased;
 	}
+}
 
-	return font_owner.make_rid(fd);
+bool TextServerAdvanced::font_is_antialiased(RID p_font_rid) const {
+	FontDataAdvanced *fd = font_owner.getornull(p_font_rid);
+	ERR_FAIL_COND_V(!fd, false);
+
+	MutexLock lock(fd->mutex);
+	return fd->antialiased;
 }
 
-void TextServerAdvanced::font_bitmap_add_texture(RID p_font, const Ref<Texture> &p_texture) {
-	_THREAD_SAFE_METHOD_
-	FontDataAdvanced *fd = font_owner.getornull(p_font);
+void TextServerAdvanced::font_set_multichannel_signed_distance_field(RID p_font_rid, bool p_msdf) {
+	FontDataAdvanced *fd = font_owner.getornull(p_font_rid);
 	ERR_FAIL_COND(!fd);
-	fd->bitmap_add_texture(p_texture);
+
+	MutexLock lock(fd->mutex);
+	if (fd->msdf != p_msdf) {
+		_font_clear_cache(fd);
+		fd->msdf = p_msdf;
+	}
 }
 
-void TextServerAdvanced::font_bitmap_add_char(RID p_font, char32_t p_char, int p_texture_idx, const Rect2 &p_rect, const Size2 &p_align, float p_advance) {
-	_THREAD_SAFE_METHOD_
-	FontDataAdvanced *fd = font_owner.getornull(p_font);
+bool TextServerAdvanced::font_is_multichannel_signed_distance_field(RID p_font_rid) const {
+	FontDataAdvanced *fd = font_owner.getornull(p_font_rid);
+	ERR_FAIL_COND_V(!fd, false);
+
+	MutexLock lock(fd->mutex);
+	return fd->msdf;
+}
+
+void TextServerAdvanced::font_set_msdf_pixel_range(RID p_font_rid, int p_msdf_pixel_range) {
+	FontDataAdvanced *fd = font_owner.getornull(p_font_rid);
 	ERR_FAIL_COND(!fd);
-	fd->bitmap_add_char(p_char, p_texture_idx, p_rect, p_align, p_advance);
+
+	MutexLock lock(fd->mutex);
+	if (fd->msdf_range != p_msdf_pixel_range) {
+		_font_clear_cache(fd);
+		fd->msdf_range = p_msdf_pixel_range;
+	}
 }
 
-void TextServerAdvanced::font_bitmap_add_kerning_pair(RID p_font, char32_t p_A, char32_t p_B, int p_kerning) {
-	_THREAD_SAFE_METHOD_
-	FontDataAdvanced *fd = font_owner.getornull(p_font);
+int TextServerAdvanced::font_get_msdf_pixel_range(RID p_font_rid) const {
+	FontDataAdvanced *fd = font_owner.getornull(p_font_rid);
+	ERR_FAIL_COND_V(!fd, false);
+
+	MutexLock lock(fd->mutex);
+	return fd->msdf_range;
+}
+
+void TextServerAdvanced::font_set_msdf_size(RID p_font_rid, int p_msdf_size) {
+	FontDataAdvanced *fd = font_owner.getornull(p_font_rid);
 	ERR_FAIL_COND(!fd);
-	fd->bitmap_add_kerning_pair(p_A, p_B, p_kerning);
+
+	MutexLock lock(fd->mutex);
+	if (fd->msdf_source_size != p_msdf_size) {
+		_font_clear_cache(fd);
+		fd->msdf_source_size = p_msdf_size;
+	}
 }
 
-float TextServerAdvanced::font_get_height(RID p_font, int p_size) const {
-	_THREAD_SAFE_METHOD_
-	const FontDataAdvanced *fd = font_owner.getornull(p_font);
+int TextServerAdvanced::font_get_msdf_size(RID p_font_rid) const {
+	FontDataAdvanced *fd = font_owner.getornull(p_font_rid);
+	ERR_FAIL_COND_V(!fd, false);
+
+	MutexLock lock(fd->mutex);
+	return fd->msdf_source_size;
+}
+
+void TextServerAdvanced::font_set_fixed_size(RID p_font_rid, int p_fixed_size) {
+	FontDataAdvanced *fd = font_owner.getornull(p_font_rid);
+	ERR_FAIL_COND(!fd);
+
+	MutexLock lock(fd->mutex);
+	if (fd->fixed_size != p_fixed_size) {
+		fd->fixed_size = p_fixed_size;
+	}
+}
+
+int TextServerAdvanced::font_get_fixed_size(RID p_font_rid) const {
+	FontDataAdvanced *fd = font_owner.getornull(p_font_rid);
+	ERR_FAIL_COND_V(!fd, false);
+
+	MutexLock lock(fd->mutex);
+	return fd->fixed_size;
+}
+
+void TextServerAdvanced::font_set_force_autohinter(RID p_font_rid, bool p_force_autohinter) {
+	FontDataAdvanced *fd = font_owner.getornull(p_font_rid);
+	ERR_FAIL_COND(!fd);
+
+	MutexLock lock(fd->mutex);
+	if (fd->force_autohinter != p_force_autohinter) {
+		_font_clear_cache(fd);
+		fd->force_autohinter = p_force_autohinter;
+	}
+}
+
+bool TextServerAdvanced::font_is_force_autohinter(RID p_font_rid) const {
+	FontDataAdvanced *fd = font_owner.getornull(p_font_rid);
+	ERR_FAIL_COND_V(!fd, false);
+
+	MutexLock lock(fd->mutex);
+	return fd->force_autohinter;
+}
+
+void TextServerAdvanced::font_set_hinting(RID p_font_rid, TextServer::Hinting p_hinting) {
+	FontDataAdvanced *fd = font_owner.getornull(p_font_rid);
+	ERR_FAIL_COND(!fd);
+
+	MutexLock lock(fd->mutex);
+	if (fd->hinting != p_hinting) {
+		_font_clear_cache(fd);
+		fd->hinting = p_hinting;
+	}
+}
+
+TextServer::Hinting TextServerAdvanced::font_get_hinting(RID p_font_rid) const {
+	FontDataAdvanced *fd = font_owner.getornull(p_font_rid);
+	ERR_FAIL_COND_V(!fd, HINTING_NONE);
+
+	MutexLock lock(fd->mutex);
+	return fd->hinting;
+}
+
+void TextServerAdvanced::font_set_variation_coordinates(RID p_font_rid, const Dictionary &p_variation_coordinates) {
+	FontDataAdvanced *fd = font_owner.getornull(p_font_rid);
+	ERR_FAIL_COND(!fd);
+
+	MutexLock lock(fd->mutex);
+	if (fd->variation_coordinates != p_variation_coordinates) {
+		_font_clear_cache(fd);
+		fd->variation_coordinates = p_variation_coordinates;
+	}
+}
+
+Dictionary TextServerAdvanced::font_get_variation_coordinates(RID p_font_rid) const {
+	FontDataAdvanced *fd = font_owner.getornull(p_font_rid);
+	ERR_FAIL_COND_V(!fd, Dictionary());
+
+	MutexLock lock(fd->mutex);
+	return fd->variation_coordinates;
+}
+
+void TextServerAdvanced::font_set_oversampling(RID p_font_rid, real_t p_oversampling) {
+	FontDataAdvanced *fd = font_owner.getornull(p_font_rid);
+	ERR_FAIL_COND(!fd);
+
+	MutexLock lock(fd->mutex);
+	if (fd->oversampling != p_oversampling) {
+		_font_clear_cache(fd);
+		fd->oversampling = p_oversampling;
+	}
+}
+
+real_t TextServerAdvanced::font_get_oversampling(RID p_font_rid) const {
+	FontDataAdvanced *fd = font_owner.getornull(p_font_rid);
+	ERR_FAIL_COND_V(!fd, 0.f);
+
+	MutexLock lock(fd->mutex);
+	return fd->oversampling;
+}
+
+Array TextServerAdvanced::font_get_size_cache_list(RID p_font_rid) const {
+	FontDataAdvanced *fd = font_owner.getornull(p_font_rid);
+	ERR_FAIL_COND_V(!fd, Array());
+
+	MutexLock lock(fd->mutex);
+	Array ret;
+	for (const Map<Vector2i, FontDataForSizeAdvanced *>::Element *E = fd->cache.front(); E; E = E->next()) {
+		ret.push_back(E->key());
+	}
+	return ret;
+}
+
+void TextServerAdvanced::font_clear_size_cache(RID p_font_rid) {
+	FontDataAdvanced *fd = font_owner.getornull(p_font_rid);
+	ERR_FAIL_COND(!fd);
+
+	MutexLock lock(fd->mutex);
+	for (const Map<Vector2i, FontDataForSizeAdvanced *>::Element *E = fd->cache.front(); E; E = E->next()) {
+		memdelete(E->get());
+	}
+	fd->cache.clear();
+}
+
+void TextServerAdvanced::font_remove_size_cache(RID p_font_rid, const Vector2i &p_size) {
+	FontDataAdvanced *fd = font_owner.getornull(p_font_rid);
+	ERR_FAIL_COND(!fd);
+
+	MutexLock lock(fd->mutex);
+	if (fd->cache.has(p_size)) {
+		memdelete(fd->cache[p_size]);
+		fd->cache.erase(p_size);
+	}
+}
+
+void TextServerAdvanced::font_set_ascent(RID p_font_rid, int p_size, real_t p_ascent) {
+	FontDataAdvanced *fd = font_owner.getornull(p_font_rid);
+	ERR_FAIL_COND(!fd);
+
+	MutexLock lock(fd->mutex);
+	Vector2i size = _get_size(fd, p_size);
+
+	ERR_FAIL_COND(!_ensure_cache_for_size(fd, size));
+	fd->cache[size]->ascent = p_ascent;
+}
+
+real_t TextServerAdvanced::font_get_ascent(RID p_font_rid, int p_size) const {
+	FontDataAdvanced *fd = font_owner.getornull(p_font_rid);
 	ERR_FAIL_COND_V(!fd, 0.f);
-	return fd->get_height(p_size);
+
+	MutexLock lock(fd->mutex);
+	Vector2i size = _get_size(fd, p_size);
+
+	ERR_FAIL_COND_V(!_ensure_cache_for_size(fd, size), 0.f);
+
+	if (fd->msdf) {
+		return fd->cache[size]->ascent * (real_t)p_size / (real_t)fd->msdf_source_size;
+	} else {
+		return fd->cache[size]->ascent;
+	}
 }
 
-float TextServerAdvanced::font_get_ascent(RID p_font, int p_size) const {
-	_THREAD_SAFE_METHOD_
-	const FontDataAdvanced *fd = font_owner.getornull(p_font);
+void TextServerAdvanced::font_set_descent(RID p_font_rid, int p_size, real_t p_descent) {
+	FontDataAdvanced *fd = font_owner.getornull(p_font_rid);
+	ERR_FAIL_COND(!fd);
+
+	Vector2i size = _get_size(fd, p_size);
+
+	ERR_FAIL_COND(!_ensure_cache_for_size(fd, size));
+	fd->cache[size]->descent = p_descent;
+}
+
+real_t TextServerAdvanced::font_get_descent(RID p_font_rid, int p_size) const {
+	FontDataAdvanced *fd = font_owner.getornull(p_font_rid);
 	ERR_FAIL_COND_V(!fd, 0.f);
-	return fd->get_ascent(p_size);
+
+	MutexLock lock(fd->mutex);
+	Vector2i size = _get_size(fd, p_size);
+
+	ERR_FAIL_COND_V(!_ensure_cache_for_size(fd, size), 0.f);
+
+	if (fd->msdf) {
+		return fd->cache[size]->descent * (real_t)p_size / (real_t)fd->msdf_source_size;
+	} else {
+		return fd->cache[size]->descent;
+	}
 }
 
-float TextServerAdvanced::font_get_descent(RID p_font, int p_size) const {
-	_THREAD_SAFE_METHOD_
-	const FontDataAdvanced *fd = font_owner.getornull(p_font);
+void TextServerAdvanced::font_set_underline_position(RID p_font_rid, int p_size, real_t p_underline_position) {
+	FontDataAdvanced *fd = font_owner.getornull(p_font_rid);
+	ERR_FAIL_COND(!fd);
+
+	MutexLock lock(fd->mutex);
+	Vector2i size = _get_size(fd, p_size);
+
+	ERR_FAIL_COND(!_ensure_cache_for_size(fd, size));
+	fd->cache[size]->underline_position = p_underline_position;
+}
+
+real_t TextServerAdvanced::font_get_underline_position(RID p_font_rid, int p_size) const {
+	FontDataAdvanced *fd = font_owner.getornull(p_font_rid);
 	ERR_FAIL_COND_V(!fd, 0.f);
-	return fd->get_descent(p_size);
+
+	MutexLock lock(fd->mutex);
+	Vector2i size = _get_size(fd, p_size);
+
+	ERR_FAIL_COND_V(!_ensure_cache_for_size(fd, size), 0.f);
+
+	if (fd->msdf) {
+		return fd->cache[size]->underline_position * (real_t)p_size / (real_t)fd->msdf_source_size;
+	} else {
+		return fd->cache[size]->underline_position;
+	}
 }
 
-float TextServerAdvanced::font_get_underline_position(RID p_font, int p_size) const {
-	_THREAD_SAFE_METHOD_
-	const FontDataAdvanced *fd = font_owner.getornull(p_font);
+void TextServerAdvanced::font_set_underline_thickness(RID p_font_rid, int p_size, real_t p_underline_thickness) {
+	FontDataAdvanced *fd = font_owner.getornull(p_font_rid);
+	ERR_FAIL_COND(!fd);
+
+	MutexLock lock(fd->mutex);
+	Vector2i size = _get_size(fd, p_size);
+
+	ERR_FAIL_COND(!_ensure_cache_for_size(fd, size));
+	fd->cache[size]->underline_thickness = p_underline_thickness;
+}
+
+real_t TextServerAdvanced::font_get_underline_thickness(RID p_font_rid, int p_size) const {
+	FontDataAdvanced *fd = font_owner.getornull(p_font_rid);
 	ERR_FAIL_COND_V(!fd, 0.f);
-	return fd->get_underline_position(p_size);
+
+	MutexLock lock(fd->mutex);
+	Vector2i size = _get_size(fd, p_size);
+
+	ERR_FAIL_COND_V(!_ensure_cache_for_size(fd, size), 0.f);
+
+	if (fd->msdf) {
+		return fd->cache[size]->underline_thickness * (real_t)p_size / (real_t)fd->msdf_source_size;
+	} else {
+		return fd->cache[size]->underline_thickness;
+	}
 }
 
-float TextServerAdvanced::font_get_underline_thickness(RID p_font, int p_size) const {
-	_THREAD_SAFE_METHOD_
-	const FontDataAdvanced *fd = font_owner.getornull(p_font);
+void TextServerAdvanced::font_set_scale(RID p_font_rid, int p_size, real_t p_scale) {
+	FontDataAdvanced *fd = font_owner.getornull(p_font_rid);
+	ERR_FAIL_COND(!fd);
+
+	MutexLock lock(fd->mutex);
+	Vector2i size = _get_size(fd, p_size);
+
+	ERR_FAIL_COND(!_ensure_cache_for_size(fd, size));
+	fd->cache[size]->scale = p_scale;
+}
+
+real_t TextServerAdvanced::font_get_scale(RID p_font_rid, int p_size) const {
+	FontDataAdvanced *fd = font_owner.getornull(p_font_rid);
 	ERR_FAIL_COND_V(!fd, 0.f);
-	return fd->get_underline_thickness(p_size);
+
+	MutexLock lock(fd->mutex);
+	Vector2i size = _get_size(fd, p_size);
+
+	ERR_FAIL_COND_V(!_ensure_cache_for_size(fd, size), 0.f);
+
+	if (fd->msdf) {
+		return fd->cache[size]->scale * (real_t)p_size / (real_t)fd->msdf_source_size;
+	} else {
+		return fd->cache[size]->scale / fd->cache[size]->oversampling;
+	}
 }
 
-int TextServerAdvanced::font_get_spacing_space(RID p_font) const {
-	_THREAD_SAFE_METHOD_
-	const FontDataAdvanced *fd = font_owner.getornull(p_font);
+void TextServerAdvanced::font_set_spacing(RID p_font_rid, int p_size, TextServer::SpacingType p_spacing, int p_value) {
+	FontDataAdvanced *fd = font_owner.getornull(p_font_rid);
+	ERR_FAIL_COND(!fd);
+
+	MutexLock lock(fd->mutex);
+	Vector2i size = _get_size(fd, p_size);
+
+	ERR_FAIL_COND(!_ensure_cache_for_size(fd, size));
+	switch (p_spacing) {
+		case TextServer::SPACING_GLYPH: {
+			fd->cache[size]->spacing_glyph = p_value;
+		} break;
+		case TextServer::SPACING_SPACE: {
+			fd->cache[size]->spacing_space = p_value;
+		} break;
+		default: {
+			ERR_FAIL_MSG("Invalid spacing type: " + itos(p_spacing));
+		} break;
+	}
+}
+
+int TextServerAdvanced::font_get_spacing(RID p_font_rid, int p_size, TextServer::SpacingType p_spacing) const {
+	FontDataAdvanced *fd = font_owner.getornull(p_font_rid);
 	ERR_FAIL_COND_V(!fd, 0);
-	return fd->get_spacing_space();
+
+	MutexLock lock(fd->mutex);
+	Vector2i size = _get_size(fd, p_size);
+
+	ERR_FAIL_COND_V(!_ensure_cache_for_size(fd, size), 0);
+
+	switch (p_spacing) {
+		case TextServer::SPACING_GLYPH: {
+			if (fd->msdf) {
+				return fd->cache[size]->spacing_glyph * (real_t)p_size / (real_t)fd->msdf_source_size;
+			} else {
+				return fd->cache[size]->spacing_glyph;
+			}
+		} break;
+		case TextServer::SPACING_SPACE: {
+			if (fd->msdf) {
+				return fd->cache[size]->spacing_space * (real_t)p_size / (real_t)fd->msdf_source_size;
+			} else {
+				return fd->cache[size]->spacing_space;
+			}
+		} break;
+		default: {
+			ERR_FAIL_V_MSG(0, "Invalid spacing type: " + itos(p_spacing));
+		} break;
+	}
+	return 0;
 }
 
-void TextServerAdvanced::font_set_spacing_space(RID p_font, int p_value) {
-	_THREAD_SAFE_METHOD_
-	FontDataAdvanced *fd = font_owner.getornull(p_font);
+int TextServerAdvanced::font_get_texture_count(RID p_font_rid, const Vector2i &p_size) const {
+	FontDataAdvanced *fd = font_owner.getornull(p_font_rid);
+	ERR_FAIL_COND_V(!fd, 0);
+
+	MutexLock lock(fd->mutex);
+	Vector2i size = _get_size_outline(fd, p_size);
+
+	ERR_FAIL_COND_V(!_ensure_cache_for_size(fd, size), 0);
+
+	return fd->cache[size]->textures.size();
+}
+
+void TextServerAdvanced::font_clear_textures(RID p_font_rid, const Vector2i &p_size) {
+	FontDataAdvanced *fd = font_owner.getornull(p_font_rid);
 	ERR_FAIL_COND(!fd);
-	fd->set_spacing_space(p_value);
+	MutexLock lock(fd->mutex);
+	Vector2i size = _get_size_outline(fd, p_size);
+
+	ERR_FAIL_COND(!_ensure_cache_for_size(fd, size));
+	fd->cache[size]->textures.clear();
 }
 
-int TextServerAdvanced::font_get_spacing_glyph(RID p_font) const {
-	_THREAD_SAFE_METHOD_
-	const FontDataAdvanced *fd = font_owner.getornull(p_font);
-	ERR_FAIL_COND_V(!fd, 0);
-	return fd->get_spacing_glyph();
+void TextServerAdvanced::font_remove_texture(RID p_font_rid, const Vector2i &p_size, int p_texture_index) {
+	FontDataAdvanced *fd = font_owner.getornull(p_font_rid);
+	ERR_FAIL_COND(!fd);
+
+	MutexLock lock(fd->mutex);
+	Vector2i size = _get_size_outline(fd, p_size);
+	ERR_FAIL_COND(!_ensure_cache_for_size(fd, size));
+	ERR_FAIL_INDEX(p_texture_index, fd->cache[size]->textures.size());
+
+	fd->cache[size]->textures.remove(p_texture_index);
 }
 
-void TextServerAdvanced::font_set_spacing_glyph(RID p_font, int p_value) {
-	_THREAD_SAFE_METHOD_
-	FontDataAdvanced *fd = font_owner.getornull(p_font);
+void TextServerAdvanced::font_set_texture_image(RID p_font_rid, const Vector2i &p_size, int p_texture_index, const Ref<Image> &p_image) {
+	FontDataAdvanced *fd = font_owner.getornull(p_font_rid);
 	ERR_FAIL_COND(!fd);
-	fd->set_spacing_glyph(p_value);
+	ERR_FAIL_COND(p_image.is_null());
+
+	MutexLock lock(fd->mutex);
+	Vector2i size = _get_size_outline(fd, p_size);
+	ERR_FAIL_COND(!_ensure_cache_for_size(fd, size));
+	ERR_FAIL_COND(p_texture_index < 0);
+	if (p_texture_index >= fd->cache[size]->textures.size()) {
+		fd->cache[size]->textures.resize(p_texture_index + 1);
+	}
+
+	FontTexture &tex = fd->cache[size]->textures.write[p_texture_index];
+
+	tex.imgdata = p_image->get_data();
+	tex.texture_w = p_image->get_width();
+	tex.texture_h = p_image->get_height();
+	tex.format = p_image->get_format();
+
+	Ref<Image> img = memnew(Image(tex.texture_w, tex.texture_h, 0, tex.format, tex.imgdata));
+	tex.texture = Ref<ImageTexture>();
+	tex.texture.instantiate();
+	tex.texture->create_from_image(img);
 }
 
-void TextServerAdvanced::font_set_antialiased(RID p_font, bool p_antialiased) {
-	_THREAD_SAFE_METHOD_
-	FontDataAdvanced *fd = font_owner.getornull(p_font);
+Ref<Image> TextServerAdvanced::font_get_texture_image(RID p_font_rid, const Vector2i &p_size, int p_texture_index) const {
+	FontDataAdvanced *fd = font_owner.getornull(p_font_rid);
+	ERR_FAIL_COND_V(!fd, Ref<Image>());
+
+	MutexLock lock(fd->mutex);
+	Vector2i size = _get_size_outline(fd, p_size);
+	ERR_FAIL_COND_V(!_ensure_cache_for_size(fd, size), Ref<Image>());
+	ERR_FAIL_INDEX_V(p_texture_index, fd->cache[size]->textures.size(), Ref<Image>());
+
+	const FontTexture &tex = fd->cache[size]->textures.write[p_texture_index];
+	Ref<Image> img = memnew(Image(tex.texture_w, tex.texture_h, 0, tex.format, tex.imgdata));
+
+	return img;
+}
+
+void TextServerAdvanced::font_set_texture_offsets(RID p_font_rid, const Vector2i &p_size, int p_texture_index, const PackedInt32Array &p_offset) {
+	FontDataAdvanced *fd = font_owner.getornull(p_font_rid);
 	ERR_FAIL_COND(!fd);
-	fd->set_antialiased(p_antialiased);
+
+	MutexLock lock(fd->mutex);
+	Vector2i size = _get_size_outline(fd, p_size);
+	ERR_FAIL_COND(!_ensure_cache_for_size(fd, size));
+	if (p_texture_index >= fd->cache[size]->textures.size()) {
+		fd->cache[size]->textures.resize(p_texture_index + 1);
+	}
+
+	FontTexture &tex = fd->cache[size]->textures.write[p_texture_index];
+	tex.offsets = p_offset;
 }
 
-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();
+PackedInt32Array TextServerAdvanced::font_get_texture_offsets(RID p_font_rid, const Vector2i &p_size, int p_texture_index) const {
+	FontDataAdvanced *fd = font_owner.getornull(p_font_rid);
+	ERR_FAIL_COND_V(!fd, PackedInt32Array());
+
+	MutexLock lock(fd->mutex);
+	Vector2i size = _get_size_outline(fd, p_size);
+	ERR_FAIL_COND_V(!_ensure_cache_for_size(fd, size), PackedInt32Array());
+	ERR_FAIL_INDEX_V(p_texture_index, fd->cache[size]->textures.size(), PackedInt32Array());
+
+	const FontTexture &tex = fd->cache[size]->textures.write[p_texture_index];
+	return tex.offsets;
 }
 
-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();
+Array TextServerAdvanced::font_get_glyph_list(RID p_font_rid, const Vector2i &p_size) const {
+	FontDataAdvanced *fd = font_owner.getornull(p_font_rid);
+	ERR_FAIL_COND_V(!fd, Array());
+
+	MutexLock lock(fd->mutex);
+	Vector2i size = _get_size_outline(fd, p_size);
+	ERR_FAIL_COND_V(!_ensure_cache_for_size(fd, size), Array());
+
+	Array ret;
+	const HashMap<int32_t, FontGlyph> &gl = fd->cache[size]->glyph_map;
+	const int32_t *E = nullptr;
+	while ((E = gl.next(E))) {
+		ret.push_back(*E);
+	}
+	return ret;
 }
 
-Dictionary TextServerAdvanced::font_get_variation_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_variation_list();
+void TextServerAdvanced::font_clear_glyphs(RID p_font_rid, const Vector2i &p_size) {
+	FontDataAdvanced *fd = font_owner.getornull(p_font_rid);
+	ERR_FAIL_COND(!fd);
+
+	MutexLock lock(fd->mutex);
+	Vector2i size = _get_size_outline(fd, p_size);
+	ERR_FAIL_COND(!_ensure_cache_for_size(fd, size));
+
+	fd->cache[size]->glyph_map.clear();
 }
 
-void TextServerAdvanced::font_set_variation(RID p_font, const String &p_name, double p_value) {
-	_THREAD_SAFE_METHOD_
-	FontDataAdvanced *fd = font_owner.getornull(p_font);
+void TextServerAdvanced::font_remove_glyph(RID p_font_rid, const Vector2i &p_size, int32_t p_glyph) {
+	FontDataAdvanced *fd = font_owner.getornull(p_font_rid);
 	ERR_FAIL_COND(!fd);
-	fd->set_variation(p_name, p_value);
+
+	MutexLock lock(fd->mutex);
+	Vector2i size = _get_size_outline(fd, p_size);
+	ERR_FAIL_COND(!_ensure_cache_for_size(fd, size));
+
+	fd->cache[size]->glyph_map.erase(p_glyph);
 }
 
-double TextServerAdvanced::font_get_variation(RID p_font, const String &p_name) const {
-	_THREAD_SAFE_METHOD_
-	const FontDataAdvanced *fd = font_owner.getornull(p_font);
-	ERR_FAIL_COND_V(!fd, 0);
-	return fd->get_variation(p_name);
+Vector2 TextServerAdvanced::font_get_glyph_advance(RID p_font_rid, int p_size, int32_t p_glyph) const {
+	FontDataAdvanced *fd = font_owner.getornull(p_font_rid);
+	ERR_FAIL_COND_V(!fd, Vector2());
+
+	MutexLock lock(fd->mutex);
+	Vector2i size = _get_size(fd, p_size);
+
+	ERR_FAIL_COND_V(!_ensure_cache_for_size(fd, size), Vector2());
+	if (!_ensure_glyph(fd, size, p_glyph)) {
+		return Vector2(); // Invalid or non graphicl glyph, do not display errors.
+	}
+
+	const HashMap<int32_t, FontGlyph> &gl = fd->cache[size]->glyph_map;
+
+	if (fd->msdf) {
+		return gl[p_glyph].advance * (real_t)p_size / (real_t)fd->msdf_source_size;
+	} else {
+		return gl[p_glyph].advance;
+	}
 }
 
-void TextServerAdvanced::font_set_distance_field_hint(RID p_font, bool p_distance_field) {
-	_THREAD_SAFE_METHOD_
-	FontDataAdvanced *fd = font_owner.getornull(p_font);
+void TextServerAdvanced::font_set_glyph_advance(RID p_font_rid, int p_size, int32_t p_glyph, const Vector2 &p_advance) {
+	FontDataAdvanced *fd = font_owner.getornull(p_font_rid);
 	ERR_FAIL_COND(!fd);
-	fd->set_distance_field_hint(p_distance_field);
+
+	MutexLock lock(fd->mutex);
+	Vector2i size = _get_size(fd, p_size);
+
+	ERR_FAIL_COND(!_ensure_cache_for_size(fd, size));
+
+	HashMap<int32_t, FontGlyph> &gl = fd->cache[size]->glyph_map;
+
+	gl[p_glyph].advance = p_advance;
+	gl[p_glyph].found = true;
 }
 
-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();
+Vector2 TextServerAdvanced::font_get_glyph_offset(RID p_font_rid, const Vector2i &p_size, int32_t p_glyph) const {
+	FontDataAdvanced *fd = font_owner.getornull(p_font_rid);
+	ERR_FAIL_COND_V(!fd, Vector2());
+
+	MutexLock lock(fd->mutex);
+	Vector2i size = _get_size_outline(fd, p_size);
+
+	ERR_FAIL_COND_V(!_ensure_cache_for_size(fd, size), Vector2());
+	if (!_ensure_glyph(fd, size, p_glyph)) {
+		return Vector2(); // Invalid or non graphicl glyph, do not display errors.
+	}
+
+	const HashMap<int32_t, FontGlyph> &gl = fd->cache[size]->glyph_map;
+
+	if (fd->msdf) {
+		return gl[p_glyph].rect.position * (real_t)p_size.x / (real_t)fd->msdf_source_size;
+	} else {
+		return gl[p_glyph].rect.position;
+	}
 }
 
-void TextServerAdvanced::font_set_hinting(RID p_font, TextServer::Hinting p_hinting) {
-	_THREAD_SAFE_METHOD_
-	FontDataAdvanced *fd = font_owner.getornull(p_font);
+void TextServerAdvanced::font_set_glyph_offset(RID p_font_rid, const Vector2i &p_size, int32_t p_glyph, const Vector2 &p_offset) {
+	FontDataAdvanced *fd = font_owner.getornull(p_font_rid);
 	ERR_FAIL_COND(!fd);
-	fd->set_hinting(p_hinting);
+
+	MutexLock lock(fd->mutex);
+	Vector2i size = _get_size_outline(fd, p_size);
+
+	ERR_FAIL_COND(!_ensure_cache_for_size(fd, size));
+
+	HashMap<int32_t, FontGlyph> &gl = fd->cache[size]->glyph_map;
+
+	gl[p_glyph].rect.position = p_offset;
+	gl[p_glyph].found = true;
 }
 
-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();
+Vector2 TextServerAdvanced::font_get_glyph_size(RID p_font_rid, const Vector2i &p_size, int32_t p_glyph) const {
+	FontDataAdvanced *fd = font_owner.getornull(p_font_rid);
+	ERR_FAIL_COND_V(!fd, Vector2());
+
+	MutexLock lock(fd->mutex);
+	Vector2i size = _get_size_outline(fd, p_size);
+
+	ERR_FAIL_COND_V(!_ensure_cache_for_size(fd, size), Vector2());
+	if (!_ensure_glyph(fd, size, p_glyph)) {
+		return Vector2(); // Invalid or non graphicl glyph, do not display errors.
+	}
+
+	const HashMap<int32_t, FontGlyph> &gl = fd->cache[size]->glyph_map;
+
+	if (fd->msdf) {
+		return gl[p_glyph].rect.size * (real_t)p_size.x / (real_t)fd->msdf_source_size;
+	} else {
+		return gl[p_glyph].rect.size;
+	}
 }
 
-void TextServerAdvanced::font_set_force_autohinter(RID p_font, bool p_enabeld) {
-	_THREAD_SAFE_METHOD_
-	FontDataAdvanced *fd = font_owner.getornull(p_font);
+void TextServerAdvanced::font_set_glyph_size(RID p_font_rid, const Vector2i &p_size, int32_t p_glyph, const Vector2 &p_gl_size) {
+	FontDataAdvanced *fd = font_owner.getornull(p_font_rid);
 	ERR_FAIL_COND(!fd);
-	fd->set_force_autohinter(p_enabeld);
+
+	MutexLock lock(fd->mutex);
+	Vector2i size = _get_size_outline(fd, p_size);
+
+	ERR_FAIL_COND(!_ensure_cache_for_size(fd, size));
+
+	HashMap<int32_t, FontGlyph> &gl = fd->cache[size]->glyph_map;
+
+	gl[p_glyph].rect.size = p_gl_size;
+	gl[p_glyph].found = true;
 }
 
-bool TextServerAdvanced::font_get_force_autohinter(RID p_font) const {
-	_THREAD_SAFE_METHOD_
-	const FontDataAdvanced *fd = font_owner.getornull(p_font);
+Rect2 TextServerAdvanced::font_get_glyph_uv_rect(RID p_font_rid, const Vector2i &p_size, int32_t p_glyph) const {
+	FontDataAdvanced *fd = font_owner.getornull(p_font_rid);
+	ERR_FAIL_COND_V(!fd, Rect2());
+
+	MutexLock lock(fd->mutex);
+	Vector2i size = _get_size_outline(fd, p_size);
+
+	ERR_FAIL_COND_V(!_ensure_cache_for_size(fd, size), Rect2());
+	if (!_ensure_glyph(fd, size, p_glyph)) {
+		return Rect2(); // Invalid or non graphicl glyph, do not display errors.
+	}
+
+	const HashMap<int32_t, FontGlyph> &gl = fd->cache[size]->glyph_map;
+	return gl[p_glyph].uv_rect;
+}
+
+void TextServerAdvanced::font_set_glyph_uv_rect(RID p_font_rid, const Vector2i &p_size, int32_t p_glyph, const Rect2 &p_uv_rect) {
+	FontDataAdvanced *fd = font_owner.getornull(p_font_rid);
+	ERR_FAIL_COND(!fd);
+
+	MutexLock lock(fd->mutex);
+	Vector2i size = _get_size_outline(fd, p_size);
+
+	ERR_FAIL_COND(!_ensure_cache_for_size(fd, size));
+
+	HashMap<int32_t, FontGlyph> &gl = fd->cache[size]->glyph_map;
+
+	gl[p_glyph].uv_rect = p_uv_rect;
+	gl[p_glyph].found = true;
+}
+
+int TextServerAdvanced::font_get_glyph_texture_idx(RID p_font_rid, const Vector2i &p_size, int32_t p_glyph) const {
+	FontDataAdvanced *fd = font_owner.getornull(p_font_rid);
+	ERR_FAIL_COND_V(!fd, -1);
+
+	MutexLock lock(fd->mutex);
+	Vector2i size = _get_size_outline(fd, p_size);
+
+	ERR_FAIL_COND_V(!_ensure_cache_for_size(fd, size), -1);
+	if (!_ensure_glyph(fd, size, p_glyph)) {
+		return -1; // Invalid or non graphicl glyph, do not display errors.
+	}
+
+	const HashMap<int32_t, FontGlyph> &gl = fd->cache[size]->glyph_map;
+	return gl[p_glyph].texture_idx;
+}
+
+void TextServerAdvanced::font_set_glyph_texture_idx(RID p_font_rid, const Vector2i &p_size, int32_t p_glyph, int p_texture_idx) {
+	FontDataAdvanced *fd = font_owner.getornull(p_font_rid);
+	ERR_FAIL_COND(!fd);
+
+	MutexLock lock(fd->mutex);
+	Vector2i size = _get_size_outline(fd, p_size);
+
+	ERR_FAIL_COND(!_ensure_cache_for_size(fd, size));
+
+	HashMap<int32_t, FontGlyph> &gl = fd->cache[size]->glyph_map;
+
+	gl[p_glyph].texture_idx = p_texture_idx;
+	gl[p_glyph].found = true;
+}
+
+bool TextServerAdvanced::font_get_glyph_contours(RID p_font_rid, int p_size, int32_t p_index, Vector<Vector3> &r_points, Vector<int32_t> &r_contours, bool &r_orientation) const {
+	FontDataAdvanced *fd = font_owner.getornull(p_font_rid);
 	ERR_FAIL_COND_V(!fd, false);
-	return fd->get_force_autohinter();
+
+	MutexLock lock(fd->mutex);
+	Vector2i size = _get_size(fd, p_size);
+
+	ERR_FAIL_COND_V(!_ensure_cache_for_size(fd, size), false);
+
+#ifdef MODULE_FREETYPE_ENABLED
+	int error = FT_Load_Glyph(fd->cache[size]->face, p_index, FT_LOAD_NO_BITMAP | (fd->force_autohinter ? FT_LOAD_FORCE_AUTOHINT : 0));
+	ERR_FAIL_COND_V(error, false);
+
+	r_points.clear();
+	r_contours.clear();
+
+	real_t h = fd->cache[size]->ascent;
+	real_t scale = (1.0 / 64.0) / fd->cache[size]->oversampling * fd->cache[size]->scale;
+	if (fd->msdf) {
+		scale = scale * (real_t)p_size / (real_t)fd->msdf_source_size;
+	}
+	for (short i = 0; i < fd->cache[size]->face->glyph->outline.n_points; i++) {
+		r_points.push_back(Vector3(fd->cache[size]->face->glyph->outline.points[i].x * scale, h - fd->cache[size]->face->glyph->outline.points[i].y * scale, FT_CURVE_TAG(fd->cache[size]->face->glyph->outline.tags[i])));
+	}
+	for (short i = 0; i < fd->cache[size]->face->glyph->outline.n_contours; i++) {
+		r_contours.push_back(fd->cache[size]->face->glyph->outline.contours[i]);
+	}
+	r_orientation = (FT_Outline_Get_Orientation(&fd->cache[size]->face->glyph->outline) == FT_ORIENTATION_FILL_RIGHT);
+#else
+	return false;
+#endif
+	return true;
 }
 
-bool TextServerAdvanced::font_has_char(RID p_font, char32_t p_char) const {
-	_THREAD_SAFE_METHOD_
-	const FontDataAdvanced *fd = font_owner.getornull(p_font);
+Array TextServerAdvanced::font_get_kerning_list(RID p_font_rid, int p_size) const {
+	FontDataAdvanced *fd = font_owner.getornull(p_font_rid);
+	ERR_FAIL_COND_V(!fd, Array());
+
+	MutexLock lock(fd->mutex);
+	Vector2i size = _get_size(fd, p_size);
+
+	ERR_FAIL_COND_V(!_ensure_cache_for_size(fd, size), Array());
+
+	Array ret;
+	for (const Map<Vector2i, Vector2>::Element *E = fd->cache[size]->kerning_map.front(); E; E = E->next()) {
+		ret.push_back(E->key());
+	}
+	return ret;
+}
+
+void TextServerAdvanced::font_clear_kerning_map(RID p_font_rid, int p_size) {
+	FontDataAdvanced *fd = font_owner.getornull(p_font_rid);
+	ERR_FAIL_COND(!fd);
+
+	MutexLock lock(fd->mutex);
+	Vector2i size = _get_size(fd, p_size);
+
+	ERR_FAIL_COND(!_ensure_cache_for_size(fd, size));
+	fd->cache[size]->kerning_map.clear();
+}
+
+void TextServerAdvanced::font_remove_kerning(RID p_font_rid, int p_size, const Vector2i &p_glyph_pair) {
+	FontDataAdvanced *fd = font_owner.getornull(p_font_rid);
+	ERR_FAIL_COND(!fd);
+
+	MutexLock lock(fd->mutex);
+	Vector2i size = _get_size(fd, p_size);
+
+	ERR_FAIL_COND(!_ensure_cache_for_size(fd, size));
+	fd->cache[size]->kerning_map.erase(p_glyph_pair);
+}
+
+void TextServerAdvanced::font_set_kerning(RID p_font_rid, int p_size, const Vector2i &p_glyph_pair, const Vector2 &p_kerning) {
+	FontDataAdvanced *fd = font_owner.getornull(p_font_rid);
+	ERR_FAIL_COND(!fd);
+
+	MutexLock lock(fd->mutex);
+	Vector2i size = _get_size(fd, p_size);
+
+	ERR_FAIL_COND(!_ensure_cache_for_size(fd, size));
+	fd->cache[size]->kerning_map[p_glyph_pair] = p_kerning;
+}
+
+Vector2 TextServerAdvanced::font_get_kerning(RID p_font_rid, int p_size, const Vector2i &p_glyph_pair) const {
+	FontDataAdvanced *fd = font_owner.getornull(p_font_rid);
+	ERR_FAIL_COND_V(!fd, Vector2());
+
+	MutexLock lock(fd->mutex);
+	Vector2i size = _get_size(fd, p_size);
+
+	ERR_FAIL_COND_V(!_ensure_cache_for_size(fd, size), Vector2());
+
+	const Map<Vector2i, Vector2> &kern = fd->cache[size]->kerning_map;
+
+	if (kern.has(p_glyph_pair)) {
+		if (fd->msdf) {
+			return kern[p_glyph_pair] * (real_t)p_size / (real_t)fd->msdf_source_size;
+		} else {
+			return kern[p_glyph_pair];
+		}
+	} else {
+#ifdef MODULE_FREETYPE_ENABLED
+		if (fd->cache[size]->face) {
+			FT_Vector delta;
+			FT_Get_Kerning(fd->cache[size]->face, p_glyph_pair.x, p_glyph_pair.y, FT_KERNING_DEFAULT, &delta);
+			if (fd->msdf) {
+				return Vector2(delta.x, delta.y) * (real_t)p_size / (real_t)fd->msdf_source_size;
+			} else {
+				return Vector2(delta.x, delta.y);
+			}
+		}
+#endif
+	}
+	return Vector2();
+}
+
+int32_t TextServerAdvanced::font_get_glyph_index(RID p_font_rid, int p_size, char32_t p_char, char32_t p_variation_selector) const {
+	FontDataAdvanced *fd = font_owner.getornull(p_font_rid);
+	ERR_FAIL_COND_V(!fd, 0);
+
+	MutexLock lock(fd->mutex);
+	Vector2i size = _get_size(fd, p_size);
+	ERR_FAIL_COND_V(!_ensure_cache_for_size(fd, size), 0);
+
+#ifdef MODULE_FREETYPE_ENABLED
+	if (fd->cache[size]->face) {
+		if (p_variation_selector) {
+			return FT_Face_GetCharVariantIndex(fd->cache[size]->face, p_char, p_variation_selector);
+		} else {
+			return FT_Get_Char_Index(fd->cache[size]->face, p_char);
+		}
+	} else {
+		return 0;
+	}
+#else
+	return (int32_t)p_char;
+#endif
+}
+
+bool TextServerAdvanced::font_has_char(RID p_font_rid, char32_t p_char) const {
+	FontDataAdvanced *fd = font_owner.getornull(p_font_rid);
 	ERR_FAIL_COND_V(!fd, false);
-	return fd->has_char(p_char);
+
+	MutexLock lock(fd->mutex);
+	if (fd->cache.is_empty()) {
+		ERR_FAIL_COND_V(!_ensure_cache_for_size(fd, fd->msdf ? Vector2i(fd->msdf_source_size, 0) : Vector2i(16, 0)), false);
+	}
+	FontDataForSizeAdvanced *at_size = fd->cache.front()->get();
+
+#ifdef MODULE_FREETYPE_ENABLED
+	if (at_size && at_size->face) {
+		return FT_Get_Char_Index(at_size->face, p_char) != 0;
+	}
+#endif
+	return (at_size) ? at_size->glyph_map.has((int32_t)p_char) : false;
 }
 
-String TextServerAdvanced::font_get_supported_chars(RID p_font) const {
-	_THREAD_SAFE_METHOD_
-	const FontDataAdvanced *fd = font_owner.getornull(p_font);
+String TextServerAdvanced::font_get_supported_chars(RID p_font_rid) const {
+	FontDataAdvanced *fd = font_owner.getornull(p_font_rid);
 	ERR_FAIL_COND_V(!fd, String());
-	return fd->get_supported_chars();
+
+	MutexLock lock(fd->mutex);
+	if (fd->cache.is_empty()) {
+		ERR_FAIL_COND_V(!_ensure_cache_for_size(fd, fd->msdf ? Vector2i(fd->msdf_source_size, 0) : Vector2i(16, 0)), String());
+	}
+	FontDataForSizeAdvanced *at_size = fd->cache.front()->get();
+
+	String chars;
+#ifdef MODULE_FREETYPE_ENABLED
+	if (at_size && at_size->face) {
+		FT_UInt gindex;
+		FT_ULong charcode = FT_Get_First_Char(at_size->face, &gindex);
+		while (gindex != 0) {
+			if (charcode != 0) {
+				chars += char32_t(charcode);
+			}
+			charcode = FT_Get_Next_Char(at_size->face, charcode, &gindex);
+		}
+		return chars;
+	}
+#endif
+	if (at_size) {
+		const HashMap<int32_t, FontGlyph> &gl = at_size->glyph_map;
+		const int32_t *E = nullptr;
+		while ((E = gl.next(E))) {
+			chars += char32_t(*E);
+		}
+	}
+	return 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();
+void TextServerAdvanced::font_render_range(RID p_font_rid, const Vector2i &p_size, char32_t p_start, char32_t p_end) {
+	FontDataAdvanced *fd = font_owner.getornull(p_font_rid);
+	ERR_FAIL_COND(!fd);
+
+	MutexLock lock(fd->mutex);
+	Vector2i size = _get_size_outline(fd, p_size);
+	ERR_FAIL_COND(!_ensure_cache_for_size(fd, size));
+	for (char32_t i = p_start; i <= p_end; i++) {
+#ifdef MODULE_FREETYPE_ENABLED
+		if (fd->cache[size]->face) {
+			_ensure_glyph(fd, size, FT_Get_Char_Index(fd->cache[size]->face, i));
+			continue;
+		}
+#endif
+		_ensure_glyph(fd, size, (int32_t)i);
+	}
 }
 
-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();
+void TextServerAdvanced::font_render_glyph(RID p_font_rid, const Vector2i &p_size, int32_t p_index) {
+	FontDataAdvanced *fd = font_owner.getornull(p_font_rid);
+	ERR_FAIL_COND(!fd);
+
+	MutexLock lock(fd->mutex);
+	Vector2i size = _get_size_outline(fd, p_size);
+	ERR_FAIL_COND(!_ensure_cache_for_size(fd, size));
+	ERR_FAIL_COND(!_ensure_glyph(fd, size, p_index));
 }
 
-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]];
+void TextServerAdvanced::font_draw_glyph(RID p_font_rid, RID p_canvas, int p_size, const Vector2 &p_pos, int32_t p_index, const Color &p_color) const {
+	FontDataAdvanced *fd = font_owner.getornull(p_font_rid);
+	ERR_FAIL_COND(!fd);
+
+	MutexLock lock(fd->mutex);
+	Vector2i size = _get_size(fd, p_size);
+	ERR_FAIL_COND(!_ensure_cache_for_size(fd, size));
+	if (!_ensure_glyph(fd, size, p_index)) {
+		return; // // Invalid or non graphicl glyph, do not display errors, nothing to draw.
+	}
+
+	const FontGlyph &gl = fd->cache[size]->glyph_map[p_index];
+	if (gl.found) {
+		ERR_FAIL_COND(gl.texture_idx < -1 || gl.texture_idx >= fd->cache[size]->textures.size());
+
+		if (gl.texture_idx != -1) {
+			Color modulate = p_color;
+#ifdef MODULE_FREETYPE_ENABLED
+			if (fd->cache[size]->face && FT_HAS_COLOR(fd->cache[size]->face)) {
+				modulate.r = modulate.g = modulate.b = 1.0;
+			}
+#endif
+			if (RenderingServer::get_singleton() != nullptr) {
+				RID texture = fd->cache[size]->textures[gl.texture_idx].texture->get_rid();
+				if (fd->msdf) {
+					Point2 cpos = p_pos;
+					cpos += gl.rect.position * (real_t)p_size / (real_t)fd->msdf_source_size;
+					Size2 csize = gl.rect.size * (real_t)p_size / (real_t)fd->msdf_source_size;
+					RenderingServer::get_singleton()->canvas_item_add_msdf_texture_rect_region(p_canvas, Rect2(cpos, csize), texture, gl.uv_rect, modulate, 0, fd->msdf_range);
+				} else {
+					Point2i cpos = p_pos;
+					cpos += gl.rect.position;
+					Size2i csize = gl.rect.size;
+					RenderingServer::get_singleton()->canvas_item_add_texture_rect_region(p_canvas, Rect2(cpos, csize), texture, gl.uv_rect, modulate, false, false);
+				}
 			}
 		}
-		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);
+void TextServerAdvanced::font_draw_glyph_outline(RID p_font_rid, RID p_canvas, int p_size, int p_outline_size, const Vector2 &p_pos, int32_t p_index, const Color &p_color) const {
+	FontDataAdvanced *fd = font_owner.getornull(p_font_rid);
 	ERR_FAIL_COND(!fd);
-	fd->lang_support_overrides[p_language] = p_supported;
+
+	MutexLock lock(fd->mutex);
+	Vector2i size = _get_size_outline(fd, Vector2i(p_size, p_outline_size));
+	ERR_FAIL_COND(!_ensure_cache_for_size(fd, size));
+	if (!_ensure_glyph(fd, size, p_index)) {
+		return; // // Invalid or non graphicl glyph, do not display errors, nothing to draw.
+	}
+
+	const FontGlyph &gl = fd->cache[size]->glyph_map[p_index];
+	if (gl.found) {
+		ERR_FAIL_COND(gl.texture_idx < -1 || gl.texture_idx >= fd->cache[size]->textures.size());
+
+		if (gl.texture_idx != -1) {
+			Color modulate = p_color;
+#ifdef MODULE_FREETYPE_ENABLED
+			if (fd->cache[size]->face && FT_HAS_COLOR(fd->cache[size]->face)) {
+				modulate.r = modulate.g = modulate.b = 1.0;
+			}
+#endif
+			if (RenderingServer::get_singleton() != nullptr) {
+				RID texture = fd->cache[size]->textures[gl.texture_idx].texture->get_rid();
+				if (fd->msdf) {
+					Point2 cpos = p_pos;
+					cpos += gl.rect.position * (real_t)p_size / (real_t)fd->msdf_source_size;
+					Size2 csize = gl.rect.size * (real_t)p_size / (real_t)fd->msdf_source_size;
+					RenderingServer::get_singleton()->canvas_item_add_msdf_texture_rect_region(p_canvas, Rect2(cpos, csize), texture, gl.uv_rect, modulate, p_outline_size * 2, fd->msdf_range);
+				} else {
+					Point2i cpos = p_pos;
+					cpos += gl.rect.position;
+					Size2i csize = gl.rect.size;
+					RenderingServer::get_singleton()->canvas_item_add_texture_rect_region(p_canvas, Rect2(cpos, csize), texture, gl.uv_rect, modulate, false, false);
+				}
+			}
+		}
+	}
 }
 
-bool TextServerAdvanced::font_get_language_support_override(RID p_font, const String &p_language) {
-	_THREAD_SAFE_METHOD_
-	FontDataAdvanced *fd = font_owner.getornull(p_font);
+bool TextServerAdvanced::font_is_language_supported(RID p_font_rid, const String &p_language) const {
+	FontDataAdvanced *fd = font_owner.getornull(p_font_rid);
 	ERR_FAIL_COND_V(!fd, false);
-	return fd->lang_support_overrides[p_language];
+
+	MutexLock lock(fd->mutex);
+	if (fd->language_support_overrides.has(p_language)) {
+		return fd->language_support_overrides[p_language];
+	} else {
+		return true;
+	}
 }
 
-void TextServerAdvanced::font_remove_language_support_override(RID p_font, const String &p_language) {
-	_THREAD_SAFE_METHOD_
-	FontDataAdvanced *fd = font_owner.getornull(p_font);
+void TextServerAdvanced::font_set_language_support_override(RID p_font_rid, const String &p_language, bool p_supported) {
+	FontDataAdvanced *fd = font_owner.getornull(p_font_rid);
 	ERR_FAIL_COND(!fd);
-	fd->lang_support_overrides.erase(p_language);
+
+	MutexLock lock(fd->mutex);
+	fd->language_support_overrides[p_language] = p_supported;
 }
 
-Vector<String> TextServerAdvanced::font_get_language_support_overrides(RID p_font) {
-	_THREAD_SAFE_METHOD_
-	FontDataAdvanced *fd = font_owner.getornull(p_font);
+bool TextServerAdvanced::font_get_language_support_override(RID p_font_rid, const String &p_language) {
+	FontDataAdvanced *fd = font_owner.getornull(p_font_rid);
+	ERR_FAIL_COND_V(!fd, false);
+
+	MutexLock lock(fd->mutex);
+	return fd->language_support_overrides[p_language];
+}
+
+void TextServerAdvanced::font_remove_language_support_override(RID p_font_rid, const String &p_language) {
+	FontDataAdvanced *fd = font_owner.getornull(p_font_rid);
+	ERR_FAIL_COND(!fd);
+
+	MutexLock lock(fd->mutex);
+	fd->language_support_overrides.erase(p_language);
+}
+
+Vector<String> TextServerAdvanced::font_get_language_support_overrides(RID p_font_rid) {
+	FontDataAdvanced *fd = font_owner.getornull(p_font_rid);
 	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());
+
+	MutexLock lock(fd->mutex);
+	Vector<String> out;
+	for (const Map<String, bool>::Element *E = fd->language_support_overrides.front(); E; E = E->next()) {
+		out.push_back(E->key());
 	}
-	return ret;
+	return out;
 }
 
-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);
+bool TextServerAdvanced::font_is_script_supported(RID p_font_rid, const String &p_script) const {
+	FontDataAdvanced *fd = font_owner.getornull(p_font_rid);
 	ERR_FAIL_COND_V(!fd, false);
+
+	MutexLock lock(fd->mutex);
 	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);
+		Vector2i size = _get_size(fd, 16);
+		ERR_FAIL_COND_V(!_ensure_cache_for_size(fd, size), false);
+		return fd->supported_scripts.has(TS->name_to_tag(p_script));
 	}
 }
 
-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);
+void TextServerAdvanced::font_set_script_support_override(RID p_font_rid, const String &p_script, bool p_supported) {
+	FontDataAdvanced *fd = font_owner.getornull(p_font_rid);
 	ERR_FAIL_COND(!fd);
+
+	MutexLock lock(fd->mutex);
 	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);
+bool TextServerAdvanced::font_get_script_support_override(RID p_font_rid, const String &p_script) {
+	FontDataAdvanced *fd = font_owner.getornull(p_font_rid);
 	ERR_FAIL_COND_V(!fd, false);
+
+	MutexLock lock(fd->mutex);
 	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);
+void TextServerAdvanced::font_remove_script_support_override(RID p_font_rid, const String &p_script) {
+	FontDataAdvanced *fd = font_owner.getornull(p_font_rid);
 	ERR_FAIL_COND(!fd);
+
+	MutexLock lock(fd->mutex);
 	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);
+Vector<String> TextServerAdvanced::font_get_script_support_overrides(RID p_font_rid) {
+	FontDataAdvanced *fd = font_owner.getornull(p_font_rid);
 	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);
+	MutexLock lock(fd->mutex);
+	Vector<String> out;
+	for (const Map<String, bool>::Element *E = fd->script_support_overrides.front(); E; E = E->next()) {
+		out.push_back(E->key());
+	}
+	return out;
 }
 
-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);
-}
+Dictionary TextServerAdvanced::font_supported_feature_list(RID p_font_rid) const {
+	FontDataAdvanced *fd = font_owner.getornull(p_font_rid);
+	ERR_FAIL_COND_V(!fd, Dictionary());
 
-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);
+	MutexLock lock(fd->mutex);
+	Vector2i size = _get_size(fd, 16);
+	ERR_FAIL_COND_V(!_ensure_cache_for_size(fd, size), Dictionary());
+	return fd->supported_features;
 }
 
-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);
-}
+Dictionary TextServerAdvanced::font_supported_variation_list(RID p_font_rid) const {
+	FontDataAdvanced *fd = font_owner.getornull(p_font_rid);
+	ERR_FAIL_COND_V(!fd, Dictionary());
 
-bool TextServerAdvanced::font_get_glyph_contours(RID p_font, int p_size, uint32_t p_index, Vector<Vector3> &r_points, Vector<int32_t> &r_contours, bool &r_orientation) const {
-	_THREAD_SAFE_METHOD_
-	const FontDataAdvanced *fd = font_owner.getornull(p_font);
-	ERR_FAIL_COND_V(!fd, false);
-	return fd->get_glyph_contours(p_size, p_index, r_points, r_contours, r_orientation);
+	MutexLock lock(fd->mutex);
+	Vector2i size = _get_size(fd, 16);
+	ERR_FAIL_COND_V(!_ensure_cache_for_size(fd, size), Dictionary());
+	return fd->supported_varaitions;
 }
 
-float TextServerAdvanced::font_get_oversampling() const {
+real_t TextServerAdvanced::font_get_global_oversampling() const {
 	return oversampling;
 }
 
-void TextServerAdvanced::font_set_oversampling(float p_oversampling) {
+void TextServerAdvanced::font_set_global_oversampling(real_t p_oversampling) {
 	_THREAD_SAFE_METHOD_
 	if (oversampling != p_oversampling) {
 		oversampling = p_oversampling;
 		List<RID> fonts;
 		font_owner.get_owned_list(&fonts);
+		bool font_cleared = false;
 		for (const RID &E : fonts) {
-			font_owner.getornull(E)->clear_cache();
+			if (!font_is_multichannel_signed_distance_field(E) && font_get_oversampling(E) <= 0) {
+				font_clear_size_cache(E);
+				font_cleared = true;
+			}
 		}
 
-		List<RID> text_bufs;
-		shaped_owner.get_owned_list(&text_bufs);
-		for (const RID &E : text_bufs) {
-			invalidate(shaped_owner.getornull(E));
+		if (font_cleared) {
+			List<RID> text_bufs;
+			shaped_owner.get_owned_list(&text_bufs);
+			for (const RID &E : text_bufs) {
+				invalidate(shaped_owner.getornull(E));
+			}
 		}
 	}
 }
 
-Vector<String> TextServerAdvanced::get_system_fonts() const {
-	return Vector<String>();
-}
-
 /*************************************************************************/
 /* Shaped text buffer interface                                          */
 /*************************************************************************/
@@ -1029,10 +2895,10 @@ RID TextServerAdvanced::create_shaped_text(TextServer::Direction p_direction, Te
 }
 
 void TextServerAdvanced::shaped_text_clear(RID p_shaped) {
-	_THREAD_SAFE_METHOD_
 	ShapedTextDataAdvanced *sd = shaped_owner.getornull(p_shaped);
 	ERR_FAIL_COND(!sd);
 
+	MutexLock lock(sd->mutex);
 	sd->parent = RID();
 	sd->start = 0;
 	sd->end = 0;
@@ -1044,10 +2910,10 @@ void TextServerAdvanced::shaped_text_clear(RID p_shaped) {
 }
 
 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);
 
+	MutexLock lock(sd->mutex);
 	if (sd->direction != p_direction) {
 		if (sd->parent != RID()) {
 			full_copy(sd);
@@ -1058,16 +2924,18 @@ void TextServerAdvanced::shaped_text_set_direction(RID p_shaped, TextServer::Dir
 }
 
 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);
+
+	MutexLock lock(sd->mutex);
 	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);
+
+	MutexLock lock(sd->mutex);
 	if (sd->parent != RID()) {
 		full_copy(sd);
 	}
@@ -1076,9 +2944,10 @@ void TextServerAdvanced::shaped_text_set_bidi_override(RID p_shaped, const Vecto
 }
 
 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);
+
+	MutexLock lock(sd->mutex);
 	if (sd->orientation != p_orientation) {
 		if (sd->parent != RID()) {
 			full_copy(sd);
@@ -1089,9 +2958,10 @@ void TextServerAdvanced::shaped_text_set_orientation(RID p_shaped, TextServer::O
 }
 
 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);
+
+	MutexLock lock(sd->mutex);
 	ERR_FAIL_COND(sd->parent != RID());
 	if (sd->preserve_invalid != p_enabled) {
 		sd->preserve_invalid = p_enabled;
@@ -1100,16 +2970,18 @@ void TextServerAdvanced::shaped_text_set_preserve_invalid(RID p_shaped, bool p_e
 }
 
 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);
+
+	MutexLock lock(sd->mutex);
 	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);
+
+	MutexLock lock(sd->mutex);
 	if (sd->preserve_control != p_enabled) {
 		if (sd->parent != RID()) {
 			full_copy(sd);
@@ -1120,25 +2992,31 @@ void TextServerAdvanced::shaped_text_set_preserve_control(RID p_shaped, bool p_e
 }
 
 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);
+
+	MutexLock lock(sd->mutex);
 	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);
+
+	MutexLock lock(sd->mutex);
 	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);
 
+	MutexLock lock(sd->mutex);
+	for (int i = 0; i < p_fonts.size(); i++) {
+		ERR_FAIL_COND_V(!font_owner.getornull(p_fonts[i]), false);
+	}
+
 	if (p_text.is_empty()) {
 		return true;
 	}
@@ -1194,9 +3072,10 @@ bool TextServerAdvanced::shaped_text_add_object(RID p_shaped, Variant p_key, con
 }
 
 bool TextServerAdvanced::shaped_text_resize_object(RID p_shaped, Variant p_key, const Size2 &p_size, InlineAlign p_inline_align) {
-	_THREAD_SAFE_METHOD_
 	ShapedTextData *sd = shaped_owner.getornull(p_shaped);
 	ERR_FAIL_COND_V(!sd, false);
+
+	MutexLock lock(sd->mutex);
 	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;
@@ -1231,14 +3110,13 @@ bool TextServerAdvanced::shaped_text_resize_object(RID p_shaped, Variant p_key,
 					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 (gl.font_rid.is_valid()) {
 					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));
+						sd->ascent = MAX(sd->ascent, MAX(font_get_ascent(gl.font_rid, gl.font_size), -gl.y_off));
+						sd->descent = MAX(sd->descent, MAX(font_get_descent(gl.font_rid, gl.font_size), gl.y_off));
 					} else {
-						sd->ascent = MAX(sd->ascent, Math::round(fd->get_advance(gl.index, gl.font_size).x * 0.5));
-						sd->descent = MAX(sd->descent, Math::round(fd->get_advance(gl.index, gl.font_size).x * 0.5));
+						sd->ascent = MAX(sd->ascent, Math::round(font_get_glyph_advance(gl.font_rid, gl.font_size, gl.index).x * 0.5));
+						sd->descent = MAX(sd->descent, Math::round(font_get_glyph_advance(gl.font_rid, gl.font_size, gl.index).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));
@@ -1257,8 +3135,8 @@ bool TextServerAdvanced::shaped_text_resize_object(RID p_shaped, Variant p_key,
 		}
 
 		// Align embedded objects to baseline.
-		float full_ascent = sd->ascent;
-		float full_descent = sd->descent;
+		real_t full_ascent = sd->ascent;
+		real_t full_descent = sd->descent;
 		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) {
@@ -1327,9 +3205,10 @@ bool TextServerAdvanced::shaped_text_resize_object(RID p_shaped, Variant p_key,
 }
 
 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());
+
+	MutexLock lock(sd->mutex);
 	if (sd->parent != RID()) {
 		return shaped_text_substr(sd->parent, p_start, p_length);
 	}
@@ -1363,9 +3242,6 @@ RID TextServerAdvanced::shaped_text_substr(RID p_shaped, int p_start, int p_leng
 
 		int sd_size = sd->glyphs.size();
 		const Glyph *sd_glyphs = sd->glyphs.ptr();
-		const FontDataAdvanced *fd = nullptr;
-		RID prev_rid = RID();
-
 		for (int ov = 0; ov < sd->bidi_override.size(); ov++) {
 			UErrorCode err = U_ZERO_ERROR;
 
@@ -1423,17 +3299,13 @@ RID TextServerAdvanced::shaped_text_substr(RID p_shaped, int p_start, int p_leng
 								new_sd->width += new_sd->objects[key].rect.size.y;
 							}
 						} else {
-							if (prev_rid != gl.font_rid) {
-								fd = font_owner.getornull(gl.font_rid);
-								prev_rid = gl.font_rid;
-							}
-							if (fd != nullptr) {
+							if (gl.font_rid.is_valid()) {
 								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));
+									new_sd->ascent = MAX(new_sd->ascent, MAX(font_get_ascent(gl.font_rid, gl.font_size), -gl.y_off));
+									new_sd->descent = MAX(new_sd->descent, MAX(font_get_descent(gl.font_rid, gl.font_size), gl.y_off));
 								} else {
-									new_sd->ascent = MAX(new_sd->ascent, Math::round(fd->get_advance(gl.index, gl.font_size).x * 0.5));
-									new_sd->descent = MAX(new_sd->descent, Math::round(fd->get_advance(gl.index, gl.font_size).x * 0.5));
+									new_sd->ascent = MAX(new_sd->ascent, Math::round(font_get_glyph_advance(gl.font_rid, gl.font_size, gl.index).x * 0.5));
+									new_sd->descent = MAX(new_sd->descent, Math::round(font_get_glyph_advance(gl.font_rid, gl.font_size, gl.index).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.
@@ -1454,8 +3326,8 @@ RID TextServerAdvanced::shaped_text_substr(RID p_shaped, int p_start, int p_leng
 		}
 
 		// Align embedded objects to baseline.
-		float full_ascent = new_sd->ascent;
-		float full_descent = new_sd->descent;
+		real_t full_ascent = new_sd->ascent;
+		real_t full_descent = new_sd->descent;
 		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) {
@@ -1526,16 +3398,18 @@ RID TextServerAdvanced::shaped_text_substr(RID p_shaped, int p_start, int p_leng
 }
 
 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());
+
+	MutexLock lock(sd->mutex);
 	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_
+real_t TextServerAdvanced::shaped_text_fit_to_width(RID p_shaped, real_t p_width, uint8_t /*JustificationFlag*/ p_jst_flags) {
 	ShapedTextDataAdvanced *sd = shaped_owner.getornull(p_shaped);
 	ERR_FAIL_COND_V(!sd, 0.f);
+
+	MutexLock lock(sd->mutex);
 	if (!sd->valid) {
 		const_cast<TextServerAdvanced *>(this)->shaped_text_shape(p_shaped);
 	}
@@ -1572,7 +3446,7 @@ float TextServerAdvanced::shaped_text_fit_to_width(RID p_shaped, float p_width,
 		}
 	}
 
-	float justification_width;
+	real_t justification_width;
 	if ((p_jst_flags & JUSTIFICATION_CONSTRAIN_ELLIPSIS) == JUSTIFICATION_CONSTRAIN_ELLIPSIS) {
 		if (sd->overrun_trim_data.trim_pos >= 0) {
 			start_pos = sd->overrun_trim_data.trim_pos;
@@ -1612,7 +3486,7 @@ float TextServerAdvanced::shaped_text_fit_to_width(RID p_shaped, float p_width,
 	}
 
 	if ((elongation_count > 0) && ((p_jst_flags & JUSTIFICATION_KASHIDA) == JUSTIFICATION_KASHIDA)) {
-		float delta_width_per_kashida = (p_width - justification_width) / elongation_count;
+		real_t delta_width_per_kashida = (p_width - justification_width) / elongation_count;
 		for (int i = start_pos; i <= end_pos; i++) {
 			Glyph &gl = sd->glyphs.write[i];
 			if (gl.count > 0) {
@@ -1627,19 +3501,19 @@ float TextServerAdvanced::shaped_text_fit_to_width(RID p_shaped, float p_width,
 			}
 		}
 	}
-	float adv_remain = 0;
+	real_t adv_remain = 0;
 	if ((space_count > 0) && ((p_jst_flags & JUSTIFICATION_WORD_BOUND) == JUSTIFICATION_WORD_BOUND)) {
-		float delta_width_per_space = (p_width - justification_width) / space_count;
+		real_t delta_width_per_space = (p_width - justification_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;
-					float new_advance;
+					real_t old_adv = gl.advance;
+					real_t new_advance;
 					if ((gl.flags & GRAPHEME_IS_VIRTUAL) == GRAPHEME_IS_VIRTUAL) {
 						new_advance = MAX(gl.advance + delta_width_per_space, 0.f);
 					} else {
-						new_advance = MAX(gl.advance + delta_width_per_space, 0.05 * gl.font_size);
+						new_advance = MAX(gl.advance + delta_width_per_space, 0.1 * gl.font_size);
 					}
 					gl.advance = new_advance;
 					adv_remain += (new_advance - gl.advance);
@@ -1667,10 +3541,11 @@ float TextServerAdvanced::shaped_text_fit_to_width(RID p_shaped, float p_width,
 	return sd->width;
 }
 
-float TextServerAdvanced::shaped_text_tab_align(RID p_shaped, const Vector<float> &p_tab_stops) {
-	_THREAD_SAFE_METHOD_
+real_t TextServerAdvanced::shaped_text_tab_align(RID p_shaped, const Vector<real_t> &p_tab_stops) {
 	ShapedTextDataAdvanced *sd = shaped_owner.getornull(p_shaped);
 	ERR_FAIL_COND_V(!sd, 0.f);
+
+	MutexLock lock(sd->mutex);
 	if (!sd->valid) {
 		const_cast<TextServerAdvanced *>(this)->shaped_text_shape(p_shaped);
 	}
@@ -1679,7 +3554,7 @@ float TextServerAdvanced::shaped_text_tab_align(RID p_shaped, const Vector<float
 	}
 
 	int tab_index = 0;
-	float off = 0.f;
+	real_t off = 0.f;
 
 	int start, end, delta;
 	if (sd->para_direction == DIRECTION_LTR) {
@@ -1696,7 +3571,7 @@ float TextServerAdvanced::shaped_text_tab_align(RID p_shaped, const Vector<float
 
 	for (int i = start; i != end; i += delta) {
 		if ((gl[i].flags & GRAPHEME_IS_TAB) == GRAPHEME_IS_TAB) {
-			float tab_off = 0.f;
+			real_t tab_off = 0.f;
 			while (tab_off <= off) {
 				tab_off += p_tab_stops[tab_index];
 				tab_index++;
@@ -1704,7 +3579,7 @@ float TextServerAdvanced::shaped_text_tab_align(RID p_shaped, const Vector<float
 					tab_index = 0;
 				}
 			}
-			float old_adv = gl[i].advance;
+			real_t old_adv = gl[i].advance;
 			gl[i].advance = tab_off - off;
 			sd->width += gl[i].advance - old_adv;
 			off = 0;
@@ -1716,10 +3591,11 @@ float TextServerAdvanced::shaped_text_tab_align(RID p_shaped, const Vector<float
 	return 0.f;
 }
 
-void TextServerAdvanced::shaped_text_overrun_trim_to_width(RID p_shaped_line, float p_width, uint8_t p_trim_flags) {
-	_THREAD_SAFE_METHOD_
+void TextServerAdvanced::shaped_text_overrun_trim_to_width(RID p_shaped_line, real_t p_width, uint8_t p_trim_flags) {
 	ShapedTextDataAdvanced *sd = shaped_owner.getornull(p_shaped_line);
 	ERR_FAIL_COND_MSG(!sd, "ShapedTextDataAdvanced invalid.");
+
+	MutexLock lock(sd->mutex);
 	if (!sd->valid) {
 		shaped_text_shape(p_shaped_line);
 	}
@@ -1746,18 +3622,18 @@ void TextServerAdvanced::shaped_text_overrun_trim_to_width(RID p_shaped_line, fl
 	int sd_size = sd->glyphs.size();
 	RID last_gl_font_rid = sd_glyphs[sd_size - 1].font_rid;
 	int last_gl_font_size = sd_glyphs[sd_size - 1].font_size;
-	uint32_t dot_gl_idx = font_get_glyph_index(last_gl_font_rid, '.');
-	Vector2 dot_adv = font_get_glyph_advance(last_gl_font_rid, dot_gl_idx, last_gl_font_size);
-	uint32_t whitespace_gl_idx = font_get_glyph_index(last_gl_font_rid, ' ');
-	Vector2 whitespace_adv = font_get_glyph_advance(last_gl_font_rid, whitespace_gl_idx, last_gl_font_size);
+	int32_t dot_gl_idx = font_get_glyph_index(last_gl_font_rid, last_gl_font_size, '.');
+	Vector2 dot_adv = font_get_glyph_advance(last_gl_font_rid, last_gl_font_size, dot_gl_idx);
+	int32_t whitespace_gl_idx = font_get_glyph_index(last_gl_font_rid, last_gl_font_size, ' ');
+	Vector2 whitespace_adv = font_get_glyph_advance(last_gl_font_rid, last_gl_font_size, whitespace_gl_idx);
 
 	int ellipsis_width = 0;
 	if (add_ellipsis) {
-		ellipsis_width = 3 * dot_adv.x + font_get_spacing_glyph(last_gl_font_rid) + (cut_per_word ? whitespace_adv.x : 0);
+		ellipsis_width = 3 * dot_adv.x + font_get_spacing(last_gl_font_rid, last_gl_font_size, SPACING_GLYPH) + (cut_per_word ? whitespace_adv.x : 0);
 	}
 
 	int ell_min_characters = 6;
-	float width = sd->width;
+	real_t width = sd->width;
 
 	bool is_rtl = sd->direction == DIRECTION_RTL || (sd->direction == DIRECTION_AUTO && sd->para_direction == DIRECTION_RTL);
 
@@ -1842,16 +3718,18 @@ void TextServerAdvanced::shaped_text_overrun_trim_to_width(RID p_shaped_line, fl
 }
 
 TextServer::TrimData TextServerAdvanced::shaped_text_get_trim_data(RID p_shaped) const {
-	_THREAD_SAFE_METHOD_
 	ShapedTextDataAdvanced *sd = shaped_owner.getornull(p_shaped);
 	ERR_FAIL_COND_V_MSG(!sd, TrimData(), "ShapedTextDataAdvanced invalid.");
+
+	MutexLock lock(sd->mutex);
 	return sd->overrun_trim_data;
 }
 
 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);
+
+	MutexLock lock(sd->mutex);
 	if (!sd->valid) {
 		shaped_text_shape(p_shaped);
 	}
@@ -2035,9 +3913,10 @@ _FORCE_INLINE_ int _generate_kashida_justification_opportunies(const String &p_d
 }
 
 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);
+
+	MutexLock lock(sd->mutex);
 	if (!sd->valid) {
 		shaped_text_shape(p_shaped);
 	}
@@ -2145,8 +4024,8 @@ bool TextServerAdvanced::shaped_text_update_justification_ops(RID p_shaped) {
 }
 
 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_font_t *hb_font = _font_get_hb_handle(p_font, p_font_size);
+	ERR_FAIL_COND_V(hb_font == nullptr, TextServer::Glyph());
 
 	hb_buffer_clear_contents(p_sd->hb_buffer);
 	hb_buffer_set_direction(p_sd->hb_buffer, p_direction);
@@ -2171,16 +4050,17 @@ TextServer::Glyph TextServerAdvanced::_shape_single_glyph(ShapedTextDataAdvanced
 	gl.font_size = p_font_size;
 
 	if (glyph_count > 0) {
+		real_t scale = font_get_scale(p_font, p_font_size);
 		if (p_sd->orientation == ORIENTATION_HORIZONTAL) {
-			gl.advance = Math::round(glyph_pos[0].x_advance / (64.0 / fd->get_font_scale(p_font_size)));
+			gl.advance = Math::round(glyph_pos[0].x_advance / (64.0 / scale));
 		} else {
-			gl.advance = -Math::round(glyph_pos[0].y_advance / (64.0 / fd->get_font_scale(p_font_size)));
+			gl.advance = -Math::round(glyph_pos[0].y_advance / (64.0 / scale));
 		}
 		gl.count = 1;
 
 		gl.index = glyph_info[0].codepoint;
-		gl.x_off = Math::round(glyph_pos[0].x_offset / (64.0 / fd->get_font_scale(p_font_size)));
-		gl.y_off = -Math::round(glyph_pos[0].y_offset / (64.0 / fd->get_font_scale(p_font_size)));
+		gl.x_off = Math::round(glyph_pos[0].x_offset / (64.0 / scale));
+		gl.y_off = -Math::round(glyph_pos[0].y_offset / (64.0 / scale));
 
 		if ((glyph_info[0].codepoint != 0) || !u_isgraph(p_char)) {
 			gl.flags |= GRAPHEME_IS_VALID;
@@ -2190,13 +4070,8 @@ TextServer::Glyph TextServerAdvanced::_shape_single_glyph(ShapedTextDataAdvanced
 }
 
 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]);
-	}
-
 	int fs = p_sd->spans[p_span].font_size;
-	if (fd == nullptr) {
+	if (p_fb_index >= p_fonts.size()) {
 		// Add fallback glyphs.
 		for (int i = p_start; i < p_end; i++) {
 			if (p_sd->preserve_invalid || (p_sd->preserve_control && is_control(p_sd->text[i]))) {
@@ -2227,7 +4102,8 @@ void TextServerAdvanced::_shape_run(ShapedTextDataAdvanced *p_sd, int32_t p_star
 		return;
 	}
 
-	hb_font_t *hb_font = fd->get_hb_handle(fs);
+	RID f = p_fonts[p_fb_index];
+	hb_font_t *hb_font = _font_get_hb_handle(f, fs);
 	ERR_FAIL_COND(hb_font == nullptr);
 
 	hb_buffer_clear_contents(p_sd->hb_buffer);
@@ -2307,18 +4183,19 @@ void TextServerAdvanced::_shape_run(ShapedTextDataAdvanced *p_sd, int32_t p_star
 
 			gl.index = glyph_info[i].codepoint;
 			if (gl.index != 0) {
+				real_t scale = font_get_scale(f, fs);
 				if (p_sd->orientation == ORIENTATION_HORIZONTAL) {
-					gl.advance = Math::round(glyph_pos[i].x_advance / (64.0 / fd->get_font_scale(fs)));
+					gl.advance = Math::round(glyph_pos[i].x_advance / (64.0 / scale));
 				} else {
-					gl.advance = -Math::round(glyph_pos[i].y_advance / (64.0 / fd->get_font_scale(fs)));
+					gl.advance = -Math::round(glyph_pos[i].y_advance / (64.0 / scale));
 				}
-				gl.x_off = Math::round(glyph_pos[i].x_offset / (64.0 / fd->get_font_scale(fs)));
-				gl.y_off = -Math::round(glyph_pos[i].y_offset / (64.0 / fd->get_font_scale(fs)));
+				gl.x_off = Math::round(glyph_pos[i].x_offset / (64.0 / scale));
+				gl.y_off = -Math::round(glyph_pos[i].y_offset / (64.0 / scale));
 			}
-			if (fd->get_spacing_space() && is_whitespace(p_sd->text[glyph_info[i].cluster])) {
-				gl.advance += fd->get_spacing_space();
+			if (font_get_spacing(f, fs, SPACING_SPACE) && is_whitespace(p_sd->text[glyph_info[i].cluster])) {
+				gl.advance += font_get_spacing(f, fs, SPACING_SPACE);
 			} else {
-				gl.advance += fd->get_spacing_glyph();
+				gl.advance += font_get_spacing(f, fs, SPACING_GLYPH);
 			}
 
 			if (p_sd->preserve_control) {
@@ -2356,8 +4233,8 @@ void TextServerAdvanced::_shape_run(ShapedTextDataAdvanced *p_sd, int32_t p_star
 						p_sd->ascent = MAX(p_sd->ascent, -w[i + j].y_off);
 						p_sd->descent = MAX(p_sd->descent, w[i + j].y_off);
 					} else {
-						p_sd->ascent = MAX(p_sd->ascent, Math::round(fd->get_advance(w[i + j].index, fs).x * 0.5));
-						p_sd->descent = MAX(p_sd->descent, Math::round(fd->get_advance(w[i + j].index, fs).x * 0.5));
+						p_sd->ascent = MAX(p_sd->ascent, Math::round(font_get_glyph_advance(f, fs, w[i + j].index).x * 0.5));
+						p_sd->descent = MAX(p_sd->descent, Math::round(font_get_glyph_advance(f, fs, w[i + j].index).x * 0.5));
 					}
 					p_sd->width += w[i + j].advance;
 					p_sd->glyphs.push_back(w[i + j]);
@@ -2376,18 +4253,18 @@ void TextServerAdvanced::_shape_run(ShapedTextDataAdvanced *p_sd, int32_t p_star
 		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);
 		}
-		p_sd->ascent = MAX(p_sd->ascent, fd->get_ascent(fs));
-		p_sd->descent = MAX(p_sd->descent, fd->get_descent(fs));
-		p_sd->upos = MAX(p_sd->upos, fd->get_underline_position(fs));
-		p_sd->uthk = MAX(p_sd->uthk, fd->get_underline_thickness(fs));
+		p_sd->ascent = MAX(p_sd->ascent, font_get_ascent(f, fs));
+		p_sd->descent = MAX(p_sd->descent, font_get_descent(f, fs));
+		p_sd->upos = MAX(p_sd->upos, font_get_underline_position(f, fs));
+		p_sd->uthk = MAX(p_sd->uthk, font_get_underline_thickness(f, fs));
 	}
 }
 
 bool TextServerAdvanced::shaped_text_shape(RID p_shaped) {
-	_THREAD_SAFE_METHOD_
 	ShapedTextDataAdvanced *sd = shaped_owner.getornull(p_shaped);
 	ERR_FAIL_COND_V(!sd, false);
 
+	MutexLock lock(sd->mutex);
 	if (sd->valid) {
 		return true;
 	}
@@ -2546,8 +4423,8 @@ bool TextServerAdvanced::shaped_text_shape(RID p_shaped) {
 	}
 
 	// Align embedded objects to baseline.
-	float full_ascent = sd->ascent;
-	float full_descent = sd->descent;
+	real_t full_ascent = sd->ascent;
+	real_t full_descent = sd->descent;
 	for (Map<Variant, ShapedTextData::EmbeddedObject>::Element *E = sd->objects.front(); E; E = E->next()) {
 		if (sd->orientation == ORIENTATION_HORIZONTAL) {
 			switch (E->get().inline_align & INLINE_ALIGN_TEXT_MASK) {
@@ -2614,16 +4491,18 @@ bool TextServerAdvanced::shaped_text_shape(RID p_shaped) {
 }
 
 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);
+
+	MutexLock lock(sd->mutex);
 	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>());
+
+	MutexLock lock(sd->mutex);
 	if (!sd->valid) {
 		const_cast<TextServerAdvanced *>(this)->shaped_text_shape(p_shaped);
 	}
@@ -2631,16 +4510,18 @@ Vector<TextServer::Glyph> TextServerAdvanced::shaped_text_get_glyphs(RID p_shape
 }
 
 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());
+
+	MutexLock lock(sd->mutex);
 	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>());
+
+	MutexLock lock(sd->mutex);
 	if (!sd->valid) {
 		const_cast<TextServerAdvanced *>(this)->shaped_text_shape(p_shaped);
 	}
@@ -2655,10 +4536,11 @@ Vector<TextServer::Glyph> TextServerAdvanced::shaped_text_sort_logical(RID p_sha
 }
 
 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);
+
+	MutexLock lock(sd->mutex);
 	for (const Map<Variant, ShapedTextData::EmbeddedObject>::Element *E = sd->objects.front(); E; E = E->next()) {
 		ret.push_back(E->key());
 	}
@@ -2667,9 +4549,10 @@ Array TextServerAdvanced::shaped_text_get_objects(RID p_shaped) const {
 }
 
 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());
+
+	MutexLock lock(sd->mutex);
 	ERR_FAIL_COND_V(!sd->objects.has(p_key), Rect2());
 	if (!sd->valid) {
 		const_cast<TextServerAdvanced *>(this)->shaped_text_shape(p_shaped);
@@ -2678,9 +4561,10 @@ Rect2 TextServerAdvanced::shaped_text_get_object_rect(RID p_shaped, Variant p_ke
 }
 
 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());
+
+	MutexLock lock(sd->mutex);
 	if (!sd->valid) {
 		const_cast<TextServerAdvanced *>(this)->shaped_text_shape(p_shaped);
 	}
@@ -2691,40 +4575,44 @@ Size2 TextServerAdvanced::shaped_text_get_size(RID p_shaped) const {
 	}
 }
 
-float TextServerAdvanced::shaped_text_get_ascent(RID p_shaped) const {
-	_THREAD_SAFE_METHOD_
+real_t TextServerAdvanced::shaped_text_get_ascent(RID p_shaped) const {
 	const ShapedTextDataAdvanced *sd = shaped_owner.getornull(p_shaped);
 	ERR_FAIL_COND_V(!sd, 0.f);
+
+	MutexLock lock(sd->mutex);
 	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_
+real_t TextServerAdvanced::shaped_text_get_descent(RID p_shaped) const {
 	const ShapedTextDataAdvanced *sd = shaped_owner.getornull(p_shaped);
 	ERR_FAIL_COND_V(!sd, 0.f);
+
+	MutexLock lock(sd->mutex);
 	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_
+real_t TextServerAdvanced::shaped_text_get_width(RID p_shaped) const {
 	const ShapedTextDataAdvanced *sd = shaped_owner.getornull(p_shaped);
 	ERR_FAIL_COND_V(!sd, 0.f);
+
+	MutexLock lock(sd->mutex);
 	if (!sd->valid) {
 		const_cast<TextServerAdvanced *>(this)->shaped_text_shape(p_shaped);
 	}
 	return (sd->text_trimmed ? sd->width_trimmed : sd->width);
 }
 
-float TextServerAdvanced::shaped_text_get_underline_position(RID p_shaped) const {
-	_THREAD_SAFE_METHOD_
+real_t TextServerAdvanced::shaped_text_get_underline_position(RID p_shaped) const {
 	const ShapedTextDataAdvanced *sd = shaped_owner.getornull(p_shaped);
 	ERR_FAIL_COND_V(!sd, 0.f);
+
+	MutexLock lock(sd->mutex);
 	if (!sd->valid) {
 		const_cast<TextServerAdvanced *>(this)->shaped_text_shape(p_shaped);
 	}
@@ -2732,10 +4620,11 @@ float TextServerAdvanced::shaped_text_get_underline_position(RID p_shaped) const
 	return sd->upos;
 }
 
-float TextServerAdvanced::shaped_text_get_underline_thickness(RID p_shaped) const {
-	_THREAD_SAFE_METHOD_
+real_t TextServerAdvanced::shaped_text_get_underline_thickness(RID p_shaped) const {
 	const ShapedTextDataAdvanced *sd = shaped_owner.getornull(p_shaped);
 	ERR_FAIL_COND_V(!sd, 0.f);
+
+	MutexLock lock(sd->mutex);
 	if (!sd->valid) {
 		const_cast<TextServerAdvanced *>(this)->shaped_text_shape(p_shaped);
 	}
@@ -2762,7 +4651,6 @@ static num_system_data num_systems[]{
 };
 
 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;
@@ -2789,7 +4677,6 @@ String TextServerAdvanced::format_number(const String &p_string, const String &p
 }
 
 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;
@@ -2819,7 +4706,6 @@ String TextServerAdvanced::parse_number(const String &p_string, const String &p_
 }
 
 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++) {
@@ -2849,6 +4735,9 @@ TextServerAdvanced::TextServerAdvanced() {
 
 TextServerAdvanced::~TextServerAdvanced() {
 	hb_bmp_free_font_funcs();
+	if (library != nullptr) {
+		FT_Done_FreeType(library);
+	}
 	u_cleanup();
 #ifndef ICU_STATIC_DATA
 	if (icu_data != nullptr) {
diff --git a/modules/text_server_adv/text_server_adv.h b/modules/text_server_adv/text_server_adv.h
index d19ba41a1a..5989035800 100644
--- a/modules/text_server_adv/text_server_adv.h
+++ b/modules/text_server_adv/text_server_adv.h
@@ -39,6 +39,7 @@
 #include "servers/text_server.h"
 
 #include "core/templates/rid_owner.h"
+#include "core/templates/thread_work_pool.h"
 #include "scene/resources/texture.h"
 #include "script_iterator.h"
 
@@ -53,11 +54,24 @@
 #include <unicode/ustring.h>
 #include <unicode/utypes.h>
 
+#include "modules/modules_enabled.gen.h"
+
+#ifdef MODULE_FREETYPE_ENABLED
+#include <ft2build.h>
+#include FT_FREETYPE_H
+#include FT_TRUETYPE_TABLES_H
+#include FT_STROKER_H
+#include FT_ADVANCES_H
+#include FT_MULTIPLE_MASTERS_H
+#include FT_BBOX_H
+
+#include <hb-ft.h>
+#include <hb-ot.h>
+#endif
+
 #include <hb-icu.h>
 #include <hb.h>
 
-#include "font_adv.h"
-
 class TextServerAdvanced : public TextServer {
 	GDCLASS(TextServerAdvanced, TextServer);
 	_THREAD_SAFE_CLASS_
@@ -65,8 +79,149 @@ class TextServerAdvanced : public TextServer {
 	static String interface_name;
 	static uint32_t interface_features;
 
+	// ICU support data.
+
 	uint8_t *icu_data = nullptr;
 
+	// Font cache data.
+
+#ifdef MODULE_FREETYPE_ENABLED
+	mutable FT_Library library = nullptr;
+#endif
+
+	const int rect_range = 2;
+
+	struct FontTexture {
+		Image::Format format;
+		PackedByteArray imgdata;
+		int texture_w = 0;
+		int texture_h = 0;
+		PackedInt32Array offsets;
+		Ref<ImageTexture> texture;
+	};
+
+	struct FontTexturePosition {
+		int index = 0;
+		int x = 0;
+		int y = 0;
+	};
+
+	struct FontGlyph {
+		bool found = false;
+		int texture_idx = -1;
+		Rect2 rect;
+		Rect2 uv_rect;
+		Vector2 advance;
+	};
+
+	struct FontDataForSizeAdvanced {
+		real_t ascent = 0.f;
+		real_t descent = 0.f;
+		real_t underline_position = 0.f;
+		real_t underline_thickness = 0.f;
+		real_t scale = 1.f;
+		real_t oversampling = 1.f;
+
+		int spacing_glyph = 0;
+		int spacing_space = 0;
+
+		Vector2i size;
+
+		Vector<FontTexture> textures;
+		HashMap<int32_t, FontGlyph> glyph_map;
+		Map<Vector2i, Vector2> kerning_map;
+
+		hb_font_t *hb_handle = nullptr;
+
+#ifdef MODULE_FREETYPE_ENABLED
+		FT_Face face = nullptr;
+		FT_StreamRec stream;
+#endif
+
+		~FontDataForSizeAdvanced() {
+			if (hb_handle != nullptr) {
+				hb_font_destroy(hb_handle);
+			}
+#ifdef MODULE_FREETYPE_ENABLED
+			if (face != nullptr) {
+				FT_Done_Face(face);
+			}
+#endif
+		}
+	};
+
+	struct FontDataAdvanced {
+		Mutex mutex;
+
+		bool antialiased = true;
+		bool msdf = false;
+		int msdf_range = 14;
+		int msdf_source_size = 48;
+		int fixed_size = 0;
+		bool force_autohinter = false;
+		TextServer::Hinting hinting = TextServer::HINTING_LIGHT;
+		Dictionary variation_coordinates;
+		real_t oversampling = 0.f;
+
+		Map<Vector2i, FontDataForSizeAdvanced *> cache;
+
+		bool face_init = false;
+		Set<uint32_t> supported_scripts;
+		Dictionary supported_features;
+		Dictionary supported_varaitions;
+
+		// Language/script support override.
+		Map<String, bool> language_support_overrides;
+		Map<String, bool> script_support_overrides;
+
+		PackedByteArray data;
+		const uint8_t *data_ptr;
+		size_t data_size;
+		mutable ThreadWorkPool work_pool;
+
+		~FontDataAdvanced() {
+			work_pool.finish();
+			for (const Map<Vector2i, FontDataForSizeAdvanced *>::Element *E = cache.front(); E; E = E->next()) {
+				memdelete(E->get());
+			}
+			cache.clear();
+		}
+	};
+
+	_FORCE_INLINE_ FontTexturePosition find_texture_pos_for_glyph(FontDataForSizeAdvanced *p_data, int p_color_size, Image::Format p_image_format, int p_width, int p_height) const;
+#ifdef MODULE_MSDFGEN_ENABLED
+	_FORCE_INLINE_ FontGlyph rasterize_msdf(FontDataAdvanced *p_font_data, FontDataForSizeAdvanced *p_data, int p_pixel_range, int p_rect_margin, FT_Outline *outline, const Vector2 &advance) const;
+#endif
+#ifdef MODULE_FREETYPE_ENABLED
+	_FORCE_INLINE_ FontGlyph rasterize_bitmap(FontDataForSizeAdvanced *p_data, int p_rect_margin, FT_Bitmap bitmap, int yofs, int xofs, const Vector2 &advance) const;
+#endif
+	_FORCE_INLINE_ bool _ensure_glyph(FontDataAdvanced *p_font_data, const Vector2i &p_size, int32_t p_glyph) const;
+	_FORCE_INLINE_ bool _ensure_cache_for_size(FontDataAdvanced *p_font_data, const Vector2i &p_size) const;
+	_FORCE_INLINE_ void _font_clear_cache(FontDataAdvanced *p_font_data);
+	void _generateMTSDF_threaded(uint32_t y, void *p_td) const;
+
+	_FORCE_INLINE_ Vector2i _get_size(const FontDataAdvanced *p_font_data, int p_size) const {
+		if (p_font_data->msdf) {
+			return Vector2i(p_font_data->msdf_source_size, 0);
+		} else if (p_font_data->fixed_size > 0) {
+			return Vector2i(p_font_data->fixed_size, 0);
+		} else {
+			return Vector2i(p_size, 0);
+		}
+	}
+
+	_FORCE_INLINE_ Vector2i _get_size_outline(const FontDataAdvanced *p_font_data, const Vector2i &p_size) const {
+		if (p_font_data->msdf) {
+			return Vector2i(p_font_data->msdf_source_size, 0);
+		} else if (p_font_data->fixed_size > 0) {
+			return Vector2i(p_font_data->fixed_size, MIN(p_size.y, 1));
+		} else {
+			return p_size;
+		}
+	}
+
+	// Shaped text cache data.
+
 	struct ShapedTextDataAdvanced : public ShapedTextData {
 		/* Intermediate data */
 		Char16String utf16;
@@ -88,7 +243,9 @@ class TextServerAdvanced : public TextServer {
 		}
 	};
 
-	float oversampling = 1.f;
+	// Common data.
+
+	real_t oversampling = 1.f;
 	mutable RID_PtrOwner<FontDataAdvanced> font_owner;
 	mutable RID_PtrOwner<ShapedTextDataAdvanced> shaped_owner;
 
@@ -97,6 +254,30 @@ class TextServerAdvanced : public TextServer {
 	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);
 
+	// HarfBuzz bitmap font interface.
+
+	static hb_font_funcs_t *funcs;
+
+	struct hb_bmp_font_t {
+		TextServerAdvanced::FontDataForSizeAdvanced *face = nullptr;
+		bool unref = false; /* Whether to destroy bm_face when done. */
+	};
+
+	static hb_bmp_font_t *_hb_bmp_font_create(TextServerAdvanced::FontDataForSizeAdvanced *p_face, bool p_unref);
+	static void _hb_bmp_font_destroy(void *p_data);
+	static hb_bool_t hb_bmp_get_nominal_glyph(hb_font_t *p_font, void *p_font_data, hb_codepoint_t p_unicode, hb_codepoint_t *r_glyph, void *p_user_data);
+	static hb_position_t hb_bmp_get_glyph_h_advance(hb_font_t *p_font, void *p_font_data, hb_codepoint_t p_glyph, void *p_user_data);
+	static hb_position_t hb_bmp_get_glyph_v_advance(hb_font_t *p_font, void *p_font_data, hb_codepoint_t p_glyph, void *p_user_data);
+	static hb_position_t hb_bmp_get_glyph_h_kerning(hb_font_t *p_font, void *p_font_data, hb_codepoint_t p_left_glyph, hb_codepoint_t p_right_glyph, void *p_user_data);
+	static hb_position_t hb_bmp_get_glyph_v_kerning(hb_font_t *p_font, void *p_font_data, hb_codepoint_t p_left_glyph, hb_codepoint_t p_right_glyph, void *p_user_data);
+	static hb_bool_t hb_bmp_get_glyph_v_origin(hb_font_t *p_font, void *p_font_data, hb_codepoint_t p_glyph, hb_position_t *r_x, hb_position_t *r_y, void *p_user_data);
+	static hb_bool_t hb_bmp_get_glyph_extents(hb_font_t *p_font, void *p_font_data, hb_codepoint_t p_glyph, hb_glyph_extents_t *r_extents, void *p_user_data);
+	static hb_bool_t hb_bmp_get_font_h_extents(hb_font_t *p_font, void *p_font_data, hb_font_extents_t *r_metrics, void *p_user_data);
+	static void hb_bmp_create_font_funcs();
+	static void hb_bmp_free_font_funcs();
+	static void _hb_bmp_font_set_funcs(hb_font_t *p_font, TextServerAdvanced::FontDataForSizeAdvanced *p_face, bool p_unref);
+	static hb_font_t *hb_bmp_font_create(TextServerAdvanced::FontDataForSizeAdvanced *p_face, hb_destroy_func_t p_destroy);
+
 protected:
 	static void _bind_methods(){};
 
@@ -119,81 +300,132 @@ public:
 
 	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;
+	virtual int32_t name_to_tag(const String &p_name) const override;
+	virtual String tag_to_name(int32_t p_tag) const 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 RID create_font_bitmap(float p_height, float p_ascent, int p_base_size = 16) override;
+	virtual RID create_font() override;
+
+	virtual void font_set_data(RID p_font_rid, const PackedByteArray &p_data) override;
+	virtual void font_set_data_ptr(RID p_font_rid, const uint8_t *p_data_ptr, size_t p_data_size) override;
+
+	virtual void font_set_antialiased(RID p_font_rid, bool p_antialiased) override;
+	virtual bool font_is_antialiased(RID p_font_rid) const override;
+
+	virtual void font_set_multichannel_signed_distance_field(RID p_font_rid, bool p_msdf) override;
+	virtual bool font_is_multichannel_signed_distance_field(RID p_font_rid) const override;
+
+	virtual void font_set_msdf_pixel_range(RID p_font_rid, int p_msdf_pixel_range) override;
+	virtual int font_get_msdf_pixel_range(RID p_font_rid) const override;
+
+	virtual void font_set_msdf_size(RID p_font_rid, int p_msdf_size) override;
+	virtual int font_get_msdf_size(RID p_font_rid) const override;
+
+	virtual void font_set_fixed_size(RID p_font_rid, int p_fixed_size) override;
+	virtual int font_get_fixed_size(RID p_font_rid) const override;
+
+	virtual void font_set_force_autohinter(RID p_font_rid, bool p_force_autohinter) override;
+	virtual bool font_is_force_autohinter(RID p_font_rid) const override;
+
+	virtual void font_set_hinting(RID p_font_rid, TextServer::Hinting p_hinting) override;
+	virtual TextServer::Hinting font_get_hinting(RID p_font_rid) const override;
+
+	virtual void font_set_variation_coordinates(RID p_font_rid, const Dictionary &p_variation_coordinates) override;
+	virtual Dictionary font_get_variation_coordinates(RID p_font_rid) const override;
+
+	virtual void font_set_oversampling(RID p_font_rid, real_t p_oversampling) override;
+	virtual real_t font_get_oversampling(RID p_font_rid) const override;
+
+	virtual Array font_get_size_cache_list(RID p_font_rid) const override;
+	virtual void font_clear_size_cache(RID p_font_rid) override;
+	virtual void font_remove_size_cache(RID p_font_rid, const Vector2i &p_size) override;
+
+	hb_font_t *_font_get_hb_handle(RID p_font, int p_font_size) const;
+
+	virtual void font_set_ascent(RID p_font_rid, int p_size, real_t p_ascent) override;
+	virtual real_t font_get_ascent(RID p_font_rid, int p_size) const override;
+
+	virtual void font_set_descent(RID p_font_rid, int p_size, real_t p_descent) override;
+	virtual real_t font_get_descent(RID p_font_rid, int p_size) const override;
+
+	virtual void font_set_underline_position(RID p_font_rid, int p_size, real_t p_underline_position) override;
+	virtual real_t font_get_underline_position(RID p_font_rid, int p_size) const override;
+
+	virtual void font_set_underline_thickness(RID p_font_rid, int p_size, real_t p_underline_thickness) override;
+	virtual real_t font_get_underline_thickness(RID p_font_rid, int p_size) const override;
+
+	virtual void font_set_scale(RID p_font_rid, int p_size, real_t p_scale) override;
+	virtual real_t font_get_scale(RID p_font_rid, int p_size) const override;
+
+	virtual void font_set_spacing(RID p_font_rid, int p_size, SpacingType p_spacing, int p_value) override;
+	virtual int font_get_spacing(RID p_font_rid, int p_size, SpacingType p_spacing) const override;
 
-	virtual void font_bitmap_add_texture(RID p_font, const Ref<Texture> &p_texture) override;
-	virtual void font_bitmap_add_char(RID p_font, char32_t p_char, int p_texture_idx, const Rect2 &p_rect, const Size2 &p_align, float p_advance) override;
-	virtual void font_bitmap_add_kerning_pair(RID p_font, char32_t p_A, char32_t p_B, int p_kerning) override;
+	virtual int font_get_texture_count(RID p_font_rid, const Vector2i &p_size) const override;
+	virtual void font_clear_textures(RID p_font_rid, const Vector2i &p_size) override;
+	virtual void font_remove_texture(RID p_font_rid, const Vector2i &p_size, int p_texture_index) 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 void font_set_texture_image(RID p_font_rid, const Vector2i &p_size, int p_texture_index, const Ref<Image> &p_image) override;
+	virtual Ref<Image> font_get_texture_image(RID p_font_rid, const Vector2i &p_size, int p_texture_index) 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_texture_offsets(RID p_font_rid, const Vector2i &p_size, int p_texture_index, const PackedInt32Array &p_offset) override;
+	virtual PackedInt32Array font_get_texture_offsets(RID p_font_rid, const Vector2i &p_size, int p_texture_index) const override;
 
-	virtual int font_get_spacing_space(RID p_font) const override;
-	virtual void font_set_spacing_space(RID p_font, int p_value) override;
+	virtual Array font_get_glyph_list(RID p_font_rid, const Vector2i &p_size) const override;
+	virtual void font_clear_glyphs(RID p_font_rid, const Vector2i &p_size) override;
+	virtual void font_remove_glyph(RID p_font_rid, const Vector2i &p_size, int32_t p_glyph) override;
 
-	virtual int font_get_spacing_glyph(RID p_font) const override;
-	virtual void font_set_spacing_glyph(RID p_font, int p_value) override;
+	virtual Vector2 font_get_glyph_advance(RID p_font_rid, int p_size, int32_t p_glyph) const override;
+	virtual void font_set_glyph_advance(RID p_font_rid, int p_size, int32_t p_glyph, const Vector2 &p_advance) override;
 
-	virtual void font_set_antialiased(RID p_font, bool p_antialiased) override;
-	virtual bool font_get_antialiased(RID p_font) const override;
+	virtual Vector2 font_get_glyph_offset(RID p_font_rid, const Vector2i &p_size, int32_t p_glyph) const override;
+	virtual void font_set_glyph_offset(RID p_font_rid, const Vector2i &p_size, int32_t p_glyph, const Vector2 &p_offset) override;
 
-	virtual Dictionary font_get_feature_list(RID p_font) const override;
-	virtual Dictionary font_get_variation_list(RID p_font) const override;
+	virtual Vector2 font_get_glyph_size(RID p_font_rid, const Vector2i &p_size, int32_t p_glyph) const override;
+	virtual void font_set_glyph_size(RID p_font_rid, const Vector2i &p_size, int32_t p_glyph, const Vector2 &p_gl_size) override;
 
-	virtual void font_set_variation(RID p_font, const String &p_name, double p_value) override;
-	virtual double font_get_variation(RID p_font, const String &p_name) const override;
+	virtual Rect2 font_get_glyph_uv_rect(RID p_font_rid, const Vector2i &p_size, int32_t p_glyph) const override;
+	virtual void font_set_glyph_uv_rect(RID p_font_rid, const Vector2i &p_size, int32_t p_glyph, const Rect2 &p_uv_rect) override;
 
-	virtual void font_set_hinting(RID p_font, Hinting p_hinting) override;
-	virtual Hinting font_get_hinting(RID p_font) const override;
+	virtual int font_get_glyph_texture_idx(RID p_font_rid, const Vector2i &p_size, int32_t p_glyph) const override;
+	virtual void font_set_glyph_texture_idx(RID p_font_rid, const Vector2i &p_size, int32_t p_glyph, int p_texture_idx) 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 bool font_get_glyph_contours(RID p_font, int p_size, int32_t p_index, Vector<Vector3> &r_points, Vector<int32_t> &r_contours, bool &r_orientation) 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 Array font_get_kerning_list(RID p_font_rid, int p_size) const override;
+	virtual void font_clear_kerning_map(RID p_font_rid, int p_size) override;
+	virtual void font_remove_kerning(RID p_font_rid, int p_size, const Vector2i &p_glyph_pair) 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 void font_set_kerning(RID p_font_rid, int p_size, const Vector2i &p_glyph_pair, const Vector2 &p_kerning) override;
+	virtual Vector2 font_get_kerning(RID p_font_rid, int p_size, const Vector2i &p_glyph_pair) const override;
 
-	virtual bool font_has_outline(RID p_font) const override;
-	virtual float font_get_base_size(RID p_font) const override;
+	virtual int32_t font_get_glyph_index(RID p_font_rid, int p_size, char32_t p_char, char32_t p_variation_selector = 0) 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_has_char(RID p_font_rid, char32_t p_char) const override;
+	virtual String font_get_supported_chars(RID p_font_rid) const 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 void font_render_range(RID p_font, const Vector2i &p_size, char32_t p_start, char32_t p_end) override;
+	virtual void font_render_glyph(RID p_font_rid, const Vector2i &p_size, int32_t p_index) 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 void font_draw_glyph(RID p_font, RID p_canvas, int p_size, const Vector2 &p_pos, int32_t p_index, const Color &p_color = Color(1, 1, 1)) const override;
+	virtual void font_draw_glyph_outline(RID p_font, RID p_canvas, int p_size, int p_outline_size, const Vector2 &p_pos, int32_t p_index, const Color &p_color = Color(1, 1, 1)) 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 bool font_is_language_supported(RID p_font_rid, const String &p_language) const override;
+	virtual void font_set_language_support_override(RID p_font_rid, const String &p_language, bool p_supported) override;
+	virtual bool font_get_language_support_override(RID p_font_rid, const String &p_language) override;
+	virtual void font_remove_language_support_override(RID p_font_rid, const String &p_language) override;
+	virtual Vector<String> font_get_language_support_overrides(RID p_font_rid) override;
 
-	virtual bool font_get_glyph_contours(RID p_font, int p_size, uint32_t p_index, Vector<Vector3> &r_points, Vector<int32_t> &r_contours, bool &r_orientation) const override;
+	virtual bool font_is_script_supported(RID p_font_rid, const String &p_script) const override;
+	virtual void font_set_script_support_override(RID p_font_rid, const String &p_script, bool p_supported) override;
+	virtual bool font_get_script_support_override(RID p_font_rid, const String &p_script) override;
+	virtual void font_remove_script_support_override(RID p_font_rid, const String &p_script) override;
+	virtual Vector<String> font_get_script_support_overrides(RID p_font_rid) override;
 
-	virtual float font_get_oversampling() const override;
-	virtual void font_set_oversampling(float p_oversampling) override;
+	virtual Dictionary font_supported_feature_list(RID p_font_rid) const override;
+	virtual Dictionary font_supported_variation_list(RID p_font_rid) const override;
 
-	virtual Vector<String> get_system_fonts() const override;
+	virtual real_t font_get_global_oversampling() const override;
+	virtual void font_set_global_oversampling(real_t p_oversampling) override;
 
 	/* Shaped text buffer interface */
 
@@ -222,14 +454,14 @@ public:
 	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 real_t shaped_text_fit_to_width(RID p_shaped, real_t p_width, uint8_t /*JustificationFlag*/ p_jst_flags = JUSTIFICATION_WORD_BOUND | JUSTIFICATION_KASHIDA) override;
+	virtual real_t shaped_text_tab_align(RID p_shaped, const Vector<real_t> &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 void shaped_text_overrun_trim_to_width(RID p_shaped, float p_width, uint8_t p_trim_flags) override;
+	virtual void shaped_text_overrun_trim_to_width(RID p_shaped, real_t p_width, uint8_t p_trim_flags) override;
 	virtual TrimData shaped_text_get_trim_data(RID p_shaped) const override;
 
 	virtual bool shaped_text_is_ready(RID p_shaped) const override;
@@ -244,11 +476,11 @@ public:
 	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 real_t shaped_text_get_ascent(RID p_shaped) const override;
+	virtual real_t shaped_text_get_descent(RID p_shaped) const override;
+	virtual real_t shaped_text_get_width(RID p_shaped) const override;
+	virtual real_t shaped_text_get_underline_position(RID p_shaped) const override;
+	virtual real_t 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;
diff --git a/modules/text_server_fb/SCsub b/modules/text_server_fb/SCsub
index 03eccbe7bd..31d1db6167 100644
--- a/modules/text_server_fb/SCsub
+++ b/modules/text_server_fb/SCsub
@@ -3,11 +3,23 @@
 Import("env")
 Import("env_modules")
 
+freetype_enabled = env.module_check_dependencies("text_server_fb", ["freetype"], True)
+msdngen_enabled = env.module_check_dependencies("text_server_fb", ["msdfgen"], True)
+
 env_text_server_fb = env_modules.Clone()
-env_text_server_fb.Append(
-    CPPPATH=[
-        "#thirdparty/freetype/include",
-    ]
-)
+
+if msdngen_enabled:
+    env_text_server_fb.Append(
+        CPPPATH=[
+            "#thirdparty/msdfgen",
+        ]
+    )
+
+if freetype_enabled:
+    env_text_server_fb.Append(
+        CPPPATH=[
+            "#thirdparty/freetype/include",
+        ]
+    )
 
 env_text_server_fb.add_source_files(env.modules_sources, "*.cpp")
diff --git a/modules/text_server_fb/bitmap_font_fb.cpp b/modules/text_server_fb/bitmap_font_fb.cpp
deleted file mode 100644
index 313f170f04..0000000000
--- a/modules/text_server_fb/bitmap_font_fb.cpp
+++ /dev/null
@@ -1,352 +0,0 @@
-/*************************************************************************/
-/*  bitmap_font_fb.cpp                                                   */
-/*************************************************************************/
-/*                       This file is part of:                           */
-/*                           GODOT ENGINE                                */
-/*                      https://godotengine.org                          */
-/*************************************************************************/
-/* Copyright (c) 2007-2021 Juan Linietsky, Ariel Manzur.                 */
-/* Copyright (c) 2014-2021 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_fb.h"
-
-Error BitmapFontDataFallback::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.y = 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.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 BitmapFontDataFallback::bitmap_new(float p_height, float p_ascent, int p_base_size) {
-	height = p_height;
-	ascent = p_ascent;
-
-	base_size = p_base_size;
-	if (base_size == 0) {
-		base_size = height;
-	}
-
-	char_map.clear();
-	textures.clear();
-	kerning_map.clear();
-
-	valid = true;
-
-	return OK;
-}
-
-void BitmapFontDataFallback::bitmap_add_texture(const Ref<Texture> &p_texture) {
-	ERR_FAIL_COND(!valid);
-	ERR_FAIL_COND_MSG(p_texture.is_null(), "It's not a reference to a valid Texture object.");
-
-	textures.push_back(p_texture);
-}
-
-void BitmapFontDataFallback::bitmap_add_char(char32_t p_char, int p_texture_idx, const Rect2 &p_rect, const Size2 &p_align, float p_advance) {
-	ERR_FAIL_COND(!valid);
-
-	Character chr;
-	chr.rect = p_rect;
-	chr.texture_idx = p_texture_idx;
-	if (p_advance < 0) {
-		chr.advance.x = chr.rect.size.x;
-	} else {
-		chr.advance.x = p_advance;
-	}
-	chr.align = p_align;
-	char_map[p_char] = chr;
-}
-
-void BitmapFontDataFallback::bitmap_add_kerning_pair(char32_t p_A, char32_t p_B, int p_kerning) {
-	ERR_FAIL_COND(!valid);
-
-	KerningPairKey kpk;
-	kpk.A = p_A;
-	kpk.B = p_B;
-
-	if (p_kerning == 0 && kerning_map.has(kpk)) {
-		kerning_map.erase(kpk);
-	} else {
-		kerning_map[kpk] = p_kerning;
-	}
-}
-
-float BitmapFontDataFallback::get_height(int p_size) const {
-	ERR_FAIL_COND_V(!valid, 0.f);
-	return height * (float(p_size) / float(base_size));
-}
-
-float BitmapFontDataFallback::get_ascent(int p_size) const {
-	ERR_FAIL_COND_V(!valid, 0.f);
-	return ascent * (float(p_size) / float(base_size));
-}
-
-float BitmapFontDataFallback::get_descent(int p_size) const {
-	ERR_FAIL_COND_V(!valid, 0.f);
-	return (height - ascent) * (float(p_size) / float(base_size));
-}
-
-float BitmapFontDataFallback::get_underline_position(int p_size) const {
-	ERR_FAIL_COND_V(!valid, 0.f);
-	return 2 * (float(p_size) / float(base_size));
-}
-
-float BitmapFontDataFallback::get_underline_thickness(int p_size) const {
-	ERR_FAIL_COND_V(!valid, 0.f);
-	return 1 * (float(p_size) / float(base_size));
-}
-
-void BitmapFontDataFallback::set_distance_field_hint(bool p_distance_field) {
-	distance_field_hint = p_distance_field;
-}
-
-bool BitmapFontDataFallback::get_distance_field_hint() const {
-	return distance_field_hint;
-}
-
-float BitmapFontDataFallback::get_base_size() const {
-	return base_size;
-}
-
-bool BitmapFontDataFallback::has_char(char32_t p_char) const {
-	_THREAD_SAFE_METHOD_
-	ERR_FAIL_COND_V(!valid, false);
-	return char_map.has(p_char);
-}
-
-String BitmapFontDataFallback::get_supported_chars() const {
-	_THREAD_SAFE_METHOD_
-	ERR_FAIL_COND_V(!valid, String());
-	String chars;
-	const char32_t *k = nullptr;
-	while ((k = char_map.next(k))) {
-		chars += char32_t(*k);
-	}
-	return chars;
-}
-
-Vector2 BitmapFontDataFallback::get_advance(char32_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 BitmapFontDataFallback::get_kerning(char32_t p_char, char32_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);
-	} else {
-		return Vector2();
-	}
-}
-
-Vector2 BitmapFontDataFallback::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) {
-		Point2i cpos = p_pos;
-		cpos += (c->align + Vector2(0, -ascent)) * (float(p_size) / float(base_size));
-		Size2i csize = c->rect.size * (float(p_size) / float(base_size));
-		if (RenderingServer::get_singleton() != nullptr) {
-			//if (distance_field_hint) { // Not implemented.
-			//	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, csize), textures[c->texture_idx]->get_rid(), c->rect, p_color, false, 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 BitmapFontDataFallback::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));
-}
diff --git a/modules/text_server_fb/bitmap_font_fb.h b/modules/text_server_fb/bitmap_font_fb.h
deleted file mode 100644
index 7cd7507ebc..0000000000
--- a/modules/text_server_fb/bitmap_font_fb.h
+++ /dev/null
@@ -1,111 +0,0 @@
-/*************************************************************************/
-/*  bitmap_font_fb.h                                                     */
-/*************************************************************************/
-/*                       This file is part of:                           */
-/*                           GODOT ENGINE                                */
-/*                      https://godotengine.org                          */
-/*************************************************************************/
-/* Copyright (c) 2007-2021 Juan Linietsky, Ariel Manzur.                 */
-/* Copyright (c) 2014-2021 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_FALLBACK_H
-#define BITMAP_FONT_FALLBACK_H
-
-#include "font_fb.h"
-
-struct BitmapFontDataFallback : public FontDataFallback {
-	_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<char32_t, Character> char_map;
-	Map<KerningPairKey, int> kerning_map;
-
-	float height = 0.f;
-	float ascent = 0.f;
-	int base_size = 0;
-	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 bitmap_new(float p_height, float p_ascent, int p_base_size) override;
-
-	virtual void bitmap_add_texture(const Ref<Texture> &p_texture) override;
-	virtual void bitmap_add_char(char32_t p_char, int p_texture_idx, const Rect2 &p_rect, const Size2 &p_align, float p_advance) override;
-	virtual void bitmap_add_kerning_pair(char32_t p_A, char32_t p_B, int p_kerning) 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 bool has_char(char32_t p_char) const override;
-	virtual String get_supported_chars() const override;
-
-	virtual Vector2 get_advance(char32_t p_char, int p_size) const override;
-	virtual Vector2 get_kerning(char32_t p_char, char32_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;
-};
-
-#endif // BITMAP_FONT_FALLBACK_H
diff --git a/modules/text_server_fb/dynamic_font_fb.cpp b/modules/text_server_fb/dynamic_font_fb.cpp
deleted file mode 100644
index 7e77987074..0000000000
--- a/modules/text_server_fb/dynamic_font_fb.cpp
+++ /dev/null
@@ -1,713 +0,0 @@
-/*************************************************************************/
-/*  dynamic_font_fb.cpp                                                  */
-/*************************************************************************/
-/*                       This file is part of:                           */
-/*                           GODOT ENGINE                                */
-/*                      https://godotengine.org                          */
-/*************************************************************************/
-/* Copyright (c) 2007-2021 Juan Linietsky, Ariel Manzur.                 */
-/* Copyright (c) 2014-2021 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_fb.h"
-
-#ifdef MODULE_FREETYPE_ENABLED
-
-#include FT_STROKER_H
-#include FT_ADVANCES_H
-
-DynamicFontDataFallback::DataAtSize *DynamicFontDataFallback::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 {
-		if (font_mem == nullptr && font_path != String()) {
-			if (!font_mem_cache.is_empty()) {
-				font_mem = font_mem_cache.ptr();
-				font_mem_size = font_mem_cache.size();
-			} else {
-				FileAccess *f = FileAccess::open(font_path, FileAccess::READ);
-				if (!f) {
-					ERR_FAIL_V_MSG(nullptr, "Cannot open font file '" + font_path + "'.");
-				}
-
-				uint64_t len = f->get_length();
-				font_mem_cache.resize(len);
-				f->get_buffer(font_mem_cache.ptrw(), len);
-				font_mem = font_mem_cache.ptr();
-				font_mem_size = len;
-				f->close();
-			}
-		}
-
-		int error = 0;
-		fds = memnew(DataAtSize);
-		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 = (-FT_MulFix(fds->face->underline_position, fds->face->size->metrics.y_scale) / 64.0) / oversampling * fds->scale_color_font;
-		fds->underline_thickness = (FT_MulFix(fds->face->underline_thickness, fds->face->size->metrics.y_scale) / 64.0) / oversampling * fds->scale_color_font;
-
-		if (p_outline_size != 0) {
-			size_cache_outline[id] = fds;
-		} else {
-			size_cache[id] = fds;
-		}
-	}
-
-	return fds;
-}
-
-DynamicFontDataFallback::TexturePosition DynamicFontDataFallback::find_texture_pos_for_glyph(DynamicFontDataFallback::DataAtSize *p_data, int p_color_size, Image::Format p_image_format, int p_width, int p_height) {
-	TexturePosition ret;
-	ret.index = -1;
-
-	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;
-}
-
-DynamicFontDataFallback::Character DynamicFontDataFallback::Character::not_found() {
-	Character ch;
-	return ch;
-}
-
-DynamicFontDataFallback::Character DynamicFontDataFallback::bitmap_to_character(DynamicFontDataFallback::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.instantiate();
-				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).round();
-	chr.advance = (advance * p_data->scale_color_font / oversampling).round();
-	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 DynamicFontDataFallback::update_char(int p_size, char32_t p_char) {
-	DataAtSize *fds = get_data_for_size(p_size, false);
-	ERR_FAIL_COND(fds == nullptr);
-
-	if (fds->char_map.has(p_char)) {
-		return;
-	}
-
-	Character character = Character::not_found();
-
-	FT_GlyphSlot slot = fds->face->glyph;
-	FT_UInt gl_index = FT_Get_Char_Index(fds->face, p_char);
-
-	if (gl_index == 0) {
-		fds->char_map[p_char] = 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, gl_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, gl_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, gl_index, FT_HAS_COLOR(fds->face) ? FT_LOAD_COLOR : FT_LOAD_DEFAULT | (force_autohinter ? FT_LOAD_FORCE_AUTOHINT : 0) | ft_hinting);
-	if (error) {
-		fds->char_map[p_char] = 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->char_map[p_char] = character;
-}
-
-void DynamicFontDataFallback::update_char_outline(int p_size, int p_outline_size, char32_t p_char) {
-	DataAtSize *fds = get_data_for_size(p_size, p_outline_size);
-	ERR_FAIL_COND(fds == nullptr);
-
-	if (fds->char_map.has(p_char)) {
-		return;
-	}
-
-	Character character = Character::not_found();
-	FT_UInt gl_index = FT_Get_Char_Index(fds->face, p_char);
-
-	if (gl_index == 0) {
-		fds->char_map[p_char] = character;
-		return;
-	}
-
-	int error = FT_Load_Glyph(fds->face, gl_index, FT_LOAD_NO_BITMAP | (force_autohinter ? FT_LOAD_FORCE_AUTOHINT : 0));
-	if (error) {
-		fds->char_map[p_char] = character;
-		return;
-	}
-
-	FT_Stroker stroker;
-	if (FT_Stroker_New(library, &stroker) != 0) {
-		fds->char_map[p_char] = 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->char_map[p_char] = character;
-}
-
-void DynamicFontDataFallback::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 DynamicFontDataFallback::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 DynamicFontDataFallback::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 DynamicFontDataFallback::get_height(int p_size) const {
-	_THREAD_SAFE_METHOD_
-	DataAtSize *fds = const_cast<DynamicFontDataFallback *>(this)->get_data_for_size(p_size);
-	ERR_FAIL_COND_V(fds == nullptr, 0.f);
-	return fds->ascent + fds->descent;
-}
-
-float DynamicFontDataFallback::get_ascent(int p_size) const {
-	_THREAD_SAFE_METHOD_
-	DataAtSize *fds = const_cast<DynamicFontDataFallback *>(this)->get_data_for_size(p_size);
-	ERR_FAIL_COND_V(fds == nullptr, 0.f);
-	return fds->ascent;
-}
-
-float DynamicFontDataFallback::get_descent(int p_size) const {
-	_THREAD_SAFE_METHOD_
-	DataAtSize *fds = const_cast<DynamicFontDataFallback *>(this)->get_data_for_size(p_size);
-	ERR_FAIL_COND_V(fds == nullptr, 0.f);
-	return fds->descent;
-}
-
-float DynamicFontDataFallback::get_underline_position(int p_size) const {
-	_THREAD_SAFE_METHOD_
-	DataAtSize *fds = const_cast<DynamicFontDataFallback *>(this)->get_data_for_size(p_size);
-	ERR_FAIL_COND_V(fds == nullptr, 0.f);
-	return fds->underline_position;
-}
-
-float DynamicFontDataFallback::get_underline_thickness(int p_size) const {
-	_THREAD_SAFE_METHOD_
-	DataAtSize *fds = const_cast<DynamicFontDataFallback *>(this)->get_data_for_size(p_size);
-	ERR_FAIL_COND_V(fds == nullptr, 0.f);
-	return fds->underline_thickness;
-}
-
-void DynamicFontDataFallback::set_antialiased(bool p_antialiased) {
-	if (antialiased != p_antialiased) {
-		clear_cache();
-		antialiased = p_antialiased;
-	}
-}
-
-bool DynamicFontDataFallback::get_antialiased() const {
-	return antialiased;
-}
-
-void DynamicFontDataFallback::set_force_autohinter(bool p_enabled) {
-	if (force_autohinter != p_enabled) {
-		clear_cache();
-		force_autohinter = p_enabled;
-	}
-}
-
-bool DynamicFontDataFallback::get_force_autohinter() const {
-	return force_autohinter;
-}
-
-void DynamicFontDataFallback::set_hinting(TextServer::Hinting p_hinting) {
-	if (hinting != p_hinting) {
-		clear_cache();
-		hinting = p_hinting;
-	}
-}
-
-TextServer::Hinting DynamicFontDataFallback::get_hinting() const {
-	return hinting;
-}
-
-bool DynamicFontDataFallback::has_outline() const {
-	return true;
-}
-
-float DynamicFontDataFallback::get_base_size() const {
-	return base_size;
-}
-
-bool DynamicFontDataFallback::has_char(char32_t p_char) const {
-	_THREAD_SAFE_METHOD_
-	DataAtSize *fds = const_cast<DynamicFontDataFallback *>(this)->get_data_for_size(base_size);
-	ERR_FAIL_COND_V(fds == nullptr, false);
-
-	const_cast<DynamicFontDataFallback *>(this)->update_char(base_size, p_char);
-	Character ch = fds->char_map[p_char];
-
-	return (ch.found);
-}
-
-String DynamicFontDataFallback::get_supported_chars() const {
-	_THREAD_SAFE_METHOD_
-	DataAtSize *fds = const_cast<DynamicFontDataFallback *>(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;
-}
-
-Vector2 DynamicFontDataFallback::get_advance(char32_t p_char, int p_size) const {
-	_THREAD_SAFE_METHOD_
-	DataAtSize *fds = const_cast<DynamicFontDataFallback *>(this)->get_data_for_size(p_size);
-	ERR_FAIL_COND_V(fds == nullptr, Vector2());
-
-	const_cast<DynamicFontDataFallback *>(this)->update_char(p_size, p_char);
-	Character ch = fds->char_map[p_char];
-
-	return ch.advance;
-}
-
-Vector2 DynamicFontDataFallback::get_kerning(char32_t p_char, char32_t p_next, int p_size) const {
-	_THREAD_SAFE_METHOD_
-	DataAtSize *fds = const_cast<DynamicFontDataFallback *>(this)->get_data_for_size(p_size);
-	ERR_FAIL_COND_V(fds == nullptr, Vector2());
-
-	FT_Vector delta;
-	FT_Get_Kerning(fds->face, FT_Get_Char_Index(fds->face, p_char), FT_Get_Char_Index(fds->face, p_next), FT_KERNING_DEFAULT, &delta);
-	return Vector2(delta.x, delta.y);
-}
-
-Vector2 DynamicFontDataFallback::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<DynamicFontDataFallback *>(this)->get_data_for_size(p_size);
-	ERR_FAIL_COND_V(fds == nullptr, Vector2());
-
-	const_cast<DynamicFontDataFallback *>(this)->update_char(p_size, p_index);
-	Character ch = fds->char_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) {
-			Point2i 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, false);
-			}
-		}
-
-		advance = ch.advance;
-	}
-
-	return advance;
-}
-
-Vector2 DynamicFontDataFallback::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<DynamicFontDataFallback *>(this)->get_data_for_size(p_size, p_outline_size);
-	ERR_FAIL_COND_V(fds == nullptr, Vector2());
-
-	const_cast<DynamicFontDataFallback *>(this)->update_char_outline(p_size, p_outline_size, p_index);
-	Character ch = fds->char_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) {
-			Point2i 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, false);
-			}
-		}
-
-		advance = ch.advance;
-	}
-
-	return advance;
-}
-
-bool DynamicFontDataFallback::get_glyph_contours(int p_size, uint32_t p_index, Vector<Vector3> &r_points, Vector<int32_t> &r_contours, bool &r_orientation) const {
-	_THREAD_SAFE_METHOD_
-	DataAtSize *fds = const_cast<DynamicFontDataFallback *>(this)->get_data_for_size(p_size);
-	ERR_FAIL_COND_V(fds == nullptr, false);
-
-	int error = FT_Load_Glyph(fds->face, p_index, FT_LOAD_NO_BITMAP | (force_autohinter ? FT_LOAD_FORCE_AUTOHINT : 0));
-	ERR_FAIL_COND_V(error, false);
-
-	r_points.clear();
-	r_contours.clear();
-
-	float h = fds->ascent;
-	float scale = (1.0 / 64.0) / oversampling * fds->scale_color_font;
-	for (short i = 0; i < fds->face->glyph->outline.n_points; i++) {
-		r_points.push_back(Vector3(fds->face->glyph->outline.points[i].x * scale, h - fds->face->glyph->outline.points[i].y * scale, FT_CURVE_TAG(fds->face->glyph->outline.tags[i])));
-	}
-	for (short i = 0; i < fds->face->glyph->outline.n_contours; i++) {
-		r_contours.push_back(fds->face->glyph->outline.contours[i]);
-	}
-	r_orientation = (FT_Outline_Get_Orientation(&fds->face->glyph->outline) == FT_ORIENTATION_FILL_RIGHT);
-	return true;
-}
-
-DynamicFontDataFallback::~DynamicFontDataFallback() {
-	clear_cache();
-	if (library != nullptr) {
-		FT_Done_FreeType(library);
-	}
-}
-
-#endif // MODULE_FREETYPE_ENABLED
diff --git a/modules/text_server_fb/dynamic_font_fb.h b/modules/text_server_fb/dynamic_font_fb.h
deleted file mode 100644
index 82e59fa607..0000000000
--- a/modules/text_server_fb/dynamic_font_fb.h
+++ /dev/null
@@ -1,173 +0,0 @@
-/*************************************************************************/
-/*  dynamic_font_fb.h                                                    */
-/*************************************************************************/
-/*                       This file is part of:                           */
-/*                           GODOT ENGINE                                */
-/*                      https://godotengine.org                          */
-/*************************************************************************/
-/* Copyright (c) 2007-2021 Juan Linietsky, Ariel Manzur.                 */
-/* Copyright (c) 2014-2021 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_FALLBACK_H
-#define DYNAMIC_FONT_FALLBACK_H
-
-#include "font_fb.h"
-
-#include "modules/modules_enabled.gen.h"
-#ifdef MODULE_FREETYPE_ENABLED
-
-#include <ft2build.h>
-#include FT_FREETYPE_H
-
-struct DynamicFontDataFallback : public FontDataFallback {
-	_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 = 0;
-		};
-		bool operator<(CacheID right) const {
-			return key < right.key;
-		}
-	};
-
-	struct DataAtSize {
-		FT_Face face = nullptr;
-		FT_StreamRec stream;
-
-		int size = 0;
-		float scale_color_font = 1.f;
-		float ascent = 0.0;
-		float descent = 0.0;
-		float underline_position = 0.0;
-		float underline_thickness = 0.0;
-
-		Vector<CharTexture> textures;
-		HashMap<char32_t, Character> char_map;
-
-		~DataAtSize() {
-			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;
-	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;
-
-	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_char(int p_size, char32_t p_char);
-	_FORCE_INLINE_ void update_char_outline(int p_size, int p_outline_size, char32_t p_char);
-
-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;
-
-	virtual void set_hinting(TextServer::Hinting p_hinting) override;
-	virtual TextServer::Hinting get_hinting() const override;
-
-	virtual void set_force_autohinter(bool p_enabeld) 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 has_char(char32_t p_char) const override;
-	virtual String get_supported_chars() const override;
-
-	virtual Vector2 get_advance(char32_t p_char, int p_size) const override;
-	virtual Vector2 get_kerning(char32_t p_char, char32_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 bool get_glyph_contours(int p_size, uint32_t p_index, Vector<Vector3> &r_points, Vector<int32_t> &r_contours, bool &r_orientation) const override;
-
-	virtual ~DynamicFontDataFallback() override;
-};
-
-#endif // MODULE_FREETYPE_ENABLED
-
-#endif // DYNAMIC_FONT_FALLBACK_H
diff --git a/modules/text_server_fb/font_fb.h b/modules/text_server_fb/font_fb.h
deleted file mode 100644
index fe9888b7f4..0000000000
--- a/modules/text_server_fb/font_fb.h
+++ /dev/null
@@ -1,101 +0,0 @@
-/*************************************************************************/
-/*  font_fb.h                                                            */
-/*************************************************************************/
-/*                       This file is part of:                           */
-/*                           GODOT ENGINE                                */
-/*                      https://godotengine.org                          */
-/*************************************************************************/
-/* Copyright (c) 2007-2021 Juan Linietsky, Ariel Manzur.                 */
-/* Copyright (c) 2014-2021 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_FALLBACK_H
-#define FONT_FALLBACK_H
-
-#include "servers/text_server.h"
-
-struct FontDataFallback {
-	Map<String, bool> lang_support_overrides;
-	Map<String, bool> script_support_overrides;
-	bool valid = false;
-	int spacing_space = 0;
-	int spacing_glyph = 0;
-
-	virtual void clear_cache() = 0;
-
-	virtual Error load_from_file(const String &p_filename, int p_base_size) { return ERR_CANT_CREATE; };
-	virtual Error load_from_memory(const uint8_t *p_data, size_t p_size, int p_base_size) { return ERR_CANT_CREATE; };
-	virtual Error bitmap_new(float p_height, float p_ascent, int p_base_size) { return ERR_CANT_CREATE; };
-
-	virtual void bitmap_add_texture(const Ref<Texture> &p_texture) { ERR_FAIL_MSG("Not supported."); };
-	virtual void bitmap_add_char(char32_t p_char, int p_texture_idx, const Rect2 &p_rect, const Size2 &p_align, float p_advance) { ERR_FAIL_MSG("Not supported."); };
-	virtual void bitmap_add_kerning_pair(char32_t p_A, char32_t p_B, int p_kerning) { ERR_FAIL_MSG("Not supported."); };
-
-	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 float get_underline_position(int p_size) const = 0;
-	virtual float get_underline_thickness(int p_size) const = 0;
-
-	virtual int get_spacing_space() const { return spacing_space; };
-	virtual void set_spacing_space(int p_value) {
-		spacing_space = p_value;
-		clear_cache();
-	};
-
-	virtual int get_spacing_glyph() const { return spacing_glyph; };
-	virtual void set_spacing_glyph(int p_value) {
-		spacing_glyph = p_value;
-		clear_cache();
-	};
-
-	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 has_char(char32_t p_char) const = 0;
-	virtual String get_supported_chars() const = 0;
-
-	virtual Vector2 get_advance(char32_t p_char, int p_size) const = 0;
-	virtual Vector2 get_kerning(char32_t p_char, char32_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 bool get_glyph_contours(int p_size, uint32_t p_index, Vector<Vector3> &r_points, Vector<int32_t> &r_contours, bool &r_orientation) const { return false; };
-
-	virtual ~FontDataFallback(){};
-};
-
-#endif // FONT_FALLBACK_H
diff --git a/modules/text_server_fb/text_server_fb.cpp b/modules/text_server_fb/text_server_fb.cpp
index 110194c373..e4e6797f92 100644
--- a/modules/text_server_fb/text_server_fb.cpp
+++ b/modules/text_server_fb/text_server_fb.cpp
@@ -30,8 +30,18 @@
 
 #include "text_server_fb.h"
 
-#include "bitmap_font_fb.h"
-#include "dynamic_font_fb.h"
+#include "core/string/print_string.h"
+
+#ifdef MODULE_MSDFGEN_ENABLED
+#include "core/ShapeDistanceFinder.h"
+#include "core/contour-combiners.h"
+#include "core/edge-selectors.h"
+#include "msdfgen.h"
+#endif
+
+/*************************************************************************/
+/*  Character properties.                                                */
+/*************************************************************************/
 
 _FORCE_INLINE_ bool is_control(char32_t p_char) {
 	return (p_char <= 0x001f) || (p_char >= 0x007f && p_char <= 0x009F);
@@ -100,291 +110,1779 @@ bool TextServerFallback::is_locale_right_to_left(const String &p_locale) {
 	return false; // No RTL support.
 }
 
+#define OT_TAG(c1, c2, c3, c4) ((int32_t)((((uint32_t)(c1)&0xFF) << 24) | (((uint32_t)(c2)&0xFF) << 16) | (((uint32_t)(c3)&0xFF) << 8) | ((uint32_t)(c4)&0xFF)))
+
+struct FeatureInfo {
+	int32_t tag;
+	String name;
+};
+
+static FeatureInfo feature_set[] = {
+	// Registered OpenType variation tags.
+	{ OT_TAG('i', 't', 'a', 'l'), "italic" },
+	{ OT_TAG('o', 'p', 's', 'z'), "optical_size" },
+	{ OT_TAG('s', 'l', 'n', 't'), "slant" },
+	{ OT_TAG('w', 'd', 't', 'h'), "width" },
+	{ OT_TAG('w', 'g', 'h', 't'), "weight" },
+	{ 0, String() },
+};
+
+_FORCE_INLINE_ int32_t ot_tag_from_string(const char *p_str, int p_len) {
+	char tag[4];
+	uint32_t i;
+
+	if (!p_str || !p_len || !*p_str)
+		return OT_TAG(0, 0, 0, 0);
+
+	if (p_len < 0 || p_len > 4) {
+		p_len = 4;
+	}
+	for (i = 0; i < (uint32_t)p_len && p_str[i]; i++) {
+		tag[i] = p_str[i];
+	}
+
+	for (; i < 4; i++) {
+		tag[i] = ' ';
+	}
+
+	return OT_TAG(tag[0], tag[1], tag[2], tag[3]);
+}
+
+int32_t TextServerFallback::name_to_tag(const String &p_name) const {
+	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 ot_tag_from_string(p_name.replace("custom_", "").ascii().get_data(), -1);
+}
+
+_FORCE_INLINE_ void ot_tag_to_string(int32_t p_tag, char *p_buf) {
+	p_buf[0] = (char)(uint8_t)(p_tag >> 24);
+	p_buf[1] = (char)(uint8_t)(p_tag >> 16);
+	p_buf[2] = (char)(uint8_t)(p_tag >> 8);
+	p_buf[3] = (char)(uint8_t)(p_tag >> 0);
+}
+
+String TextServerFallback::tag_to_name(int32_t p_tag) const {
+	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);
+	ot_tag_to_string(p_tag, name);
+	return String("custom_") + String(name);
+}
+
 /*************************************************************************/
-/* Font interface                                                        */
+/* Font Glyph Rendering                                                  */
 /*************************************************************************/
 
-RID TextServerFallback::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.");
+_FORCE_INLINE_ TextServerFallback::FontTexturePosition TextServerFallback::find_texture_pos_for_glyph(FontDataForSizeFallback *p_data, int p_color_size, Image::Format p_image_format, int p_width, int p_height) const {
+	FontTexturePosition ret;
+	ret.index = -1;
+
+	int mw = p_width;
+	int mh = p_height;
+
+	for (int i = 0; i < p_data->textures.size(); i++) {
+		const FontTexture &ct = p_data->textures[i];
+
+		if (RenderingServer::get_singleton() != nullptr) {
+			if (ct.texture->get_format() != p_image_format) {
+				continue;
+			}
+		}
+
+		if (mw > ct.texture_w || mh > ct.texture_h) { // Too big for this texture.
+			continue;
+		}
+
+		ret.y = 0x7FFFFFFF;
+		ret.x = 0;
+
+		for (int j = 0; j < ct.texture_w - 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_h) {
+			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.x * p_data->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);
+
+		FontTexture tex;
+		tex.texture_w = texsize;
+		tex.texture_h = texsize;
+		tex.format = p_image_format;
+		tex.imgdata.resize(texsize * texsize * p_color_size);
+
+		{
+			// 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, BW font.
+					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, Color font, Multichannel(+True) SDF.
+					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;
 }
 
-RID TextServerFallback::create_font_resource(const String &p_filename, int p_base_size) {
-	_THREAD_SAFE_METHOD_
-	FontDataFallback *fd = nullptr;
-	if (p_filename.get_extension() == "fnt" || p_filename.get_extension() == "font") {
-		fd = memnew(BitmapFontDataFallback);
+#ifdef MODULE_MSDFGEN_ENABLED
+
+struct MSContext {
+	msdfgen::Point2 position;
+	msdfgen::Shape *shape;
+	msdfgen::Contour *contour;
+};
+
+class DistancePixelConversion {
+	double invRange;
+
+public:
+	_FORCE_INLINE_ explicit DistancePixelConversion(double range) :
+			invRange(1 / range) {}
+	_FORCE_INLINE_ void operator()(float *pixels, const msdfgen::MultiAndTrueDistance &distance) const {
+		pixels[0] = float(invRange * distance.r + .5);
+		pixels[1] = float(invRange * distance.g + .5);
+		pixels[2] = float(invRange * distance.b + .5);
+		pixels[3] = float(invRange * distance.a + .5);
+	}
+};
+
+struct MSDFThreadData {
+	msdfgen::Bitmap<float, 4> *output;
+	msdfgen::Shape *shape;
+	msdfgen::Projection *projection;
+	DistancePixelConversion *distancePixelConversion;
+};
+
+static msdfgen::Point2 ft_point2(const FT_Vector &vector) {
+	return msdfgen::Point2(vector.x / 60.0f, vector.y / 60.0f);
+}
+
+static int ft_move_to(const FT_Vector *to, void *user) {
+	MSContext *context = reinterpret_cast<MSContext *>(user);
+	if (!(context->contour && context->contour->edges.empty())) {
+		context->contour = &context->shape->addContour();
+	}
+	context->position = ft_point2(*to);
+	return 0;
+}
+
+static int ft_line_to(const FT_Vector *to, void *user) {
+	MSContext *context = reinterpret_cast<MSContext *>(user);
+	msdfgen::Point2 endpoint = ft_point2(*to);
+	if (endpoint != context->position) {
+		context->contour->addEdge(new msdfgen::LinearSegment(context->position, endpoint));
+		context->position = endpoint;
+	}
+	return 0;
+}
+
+static int ft_conic_to(const FT_Vector *control, const FT_Vector *to, void *user) {
+	MSContext *context = reinterpret_cast<MSContext *>(user);
+	context->contour->addEdge(new msdfgen::QuadraticSegment(context->position, ft_point2(*control), ft_point2(*to)));
+	context->position = ft_point2(*to);
+	return 0;
+}
+
+static int ft_cubic_to(const FT_Vector *control1, const FT_Vector *control2, const FT_Vector *to, void *user) {
+	MSContext *context = reinterpret_cast<MSContext *>(user);
+	context->contour->addEdge(new msdfgen::CubicSegment(context->position, ft_point2(*control1), ft_point2(*control2), ft_point2(*to)));
+	context->position = ft_point2(*to);
+	return 0;
+}
+
+void TextServerFallback::_generateMTSDF_threaded(uint32_t y, void *p_td) const {
+	MSDFThreadData *td = (MSDFThreadData *)p_td;
+
+	msdfgen::ShapeDistanceFinder<msdfgen::OverlappingContourCombiner<msdfgen::MultiAndTrueDistanceSelector>> distanceFinder(*td->shape);
+	int row = td->shape->inverseYAxis ? td->output->height() - y - 1 : y;
+	for (int col = 0; col < td->output->width(); ++col) {
+		int x = (y % 2) ? td->output->width() - col - 1 : col;
+		msdfgen::Point2 p = td->projection->unproject(msdfgen::Point2(x + .5, y + .5));
+		msdfgen::MultiAndTrueDistance distance = distanceFinder.distance(p);
+		td->distancePixelConversion->operator()(td->output->operator()(x, row), distance);
+	}
+}
+
+_FORCE_INLINE_ TextServerFallback::FontGlyph TextServerFallback::rasterize_msdf(FontDataFallback *p_font_data, FontDataForSizeFallback *p_data, int p_pixel_range, int p_rect_margin, FT_Outline *outline, const Vector2 &advance) const {
+	msdfgen::Shape shape;
+
+	shape.contours.clear();
+	shape.inverseYAxis = false;
+
+	MSContext context = {};
+	context.shape = &shape;
+	FT_Outline_Funcs ft_functions;
+	ft_functions.move_to = &ft_move_to;
+	ft_functions.line_to = &ft_line_to;
+	ft_functions.conic_to = &ft_conic_to;
+	ft_functions.cubic_to = &ft_cubic_to;
+	ft_functions.shift = 0;
+	ft_functions.delta = 0;
+
+	int error = FT_Outline_Decompose(outline, &ft_functions, &context);
+	ERR_FAIL_COND_V_MSG(error, FontGlyph(), "FreeType: Outline decomposition error: '" + String(FT_Error_String(error)) + "'.");
+	if (!shape.contours.empty() && shape.contours.back().edges.empty()) {
+		shape.contours.pop_back();
+	}
+
+	if (FT_Outline_Get_Orientation(outline) == 1) {
+		for (int i = 0; i < (int)shape.contours.size(); ++i) {
+			shape.contours[i].reverse();
+		}
+	}
+
+	shape.inverseYAxis = true;
+	shape.normalize();
+
+	msdfgen::Shape::Bounds bounds = shape.getBounds(p_pixel_range);
+
+	FontGlyph chr;
+	chr.found = true;
+	chr.advance = advance.round();
+
+	if (shape.validate() && shape.contours.size() > 0) {
+		int w = (bounds.r - bounds.l);
+		int h = (bounds.t - bounds.b);
+
+		int mw = w + p_rect_margin * 2;
+		int mh = h + p_rect_margin * 2;
+
+		ERR_FAIL_COND_V(mw > 4096, FontGlyph());
+		ERR_FAIL_COND_V(mh > 4096, FontGlyph());
+
+		FontTexturePosition tex_pos = find_texture_pos_for_glyph(p_data, 4, Image::FORMAT_RGBA8, mw, mh);
+		ERR_FAIL_COND_V(tex_pos.index < 0, FontGlyph());
+		FontTexture &tex = p_data->textures.write[tex_pos.index];
+
+		edgeColoringSimple(shape, 3.0); // Max. angle.
+		msdfgen::Bitmap<real_t, 4> image(w, h); // Texture size.
+		//msdfgen::generateMTSDF(image, shape, p_pixel_range, 1.0, msdfgen::Vector2(-bounds.l, -bounds.b)); // Range, scale, translation.
+
+		DistancePixelConversion distancePixelConversion(p_pixel_range);
+		msdfgen::Projection projection(msdfgen::Vector2(1.0, 1.0), msdfgen::Vector2(-bounds.l, -bounds.b));
+		msdfgen::MSDFGeneratorConfig config(true, msdfgen::ErrorCorrectionConfig());
+
+		MSDFThreadData td;
+		td.output = &image;
+		td.shape = &shape;
+		td.projection = &projection;
+		td.distancePixelConversion = &distancePixelConversion;
+
+		if (p_font_data->work_pool.get_thread_count() == 0) {
+			p_font_data->work_pool.init();
+		}
+		p_font_data->work_pool.do_work(h, this, &TextServerFallback::_generateMTSDF_threaded, &td);
+
+		msdfgen::msdfErrorCorrection(image, shape, projection, p_pixel_range, config);
+
+		{
+			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 + p_rect_margin) * tex.texture_w + j + tex_pos.x + p_rect_margin) * 4;
+					ERR_FAIL_COND_V(ofs >= tex.imgdata.size(), FontGlyph());
+					wr[ofs + 0] = (uint8_t)(CLAMP(image(j, i)[0] * 256.f, 0.f, 255.f));
+					wr[ofs + 1] = (uint8_t)(CLAMP(image(j, i)[1] * 256.f, 0.f, 255.f));
+					wr[ofs + 2] = (uint8_t)(CLAMP(image(j, i)[2] * 256.f, 0.f, 255.f));
+					wr[ofs + 3] = (uint8_t)(CLAMP(image(j, i)[3] * 256.f, 0.f, 255.f));
+				}
+			}
+		}
+
+		// Blit to image and texture.
+		{
+			if (RenderingServer::get_singleton() != nullptr) {
+				Ref<Image> img = memnew(Image(tex.texture_w, tex.texture_h, 0, Image::FORMAT_RGBA8, tex.imgdata));
+				if (tex.texture.is_null()) {
+					tex.texture.instantiate();
+					tex.texture->create_from_image(img);
+				} else {
+					tex.texture->update(img);
+				}
+			}
+		}
+
+		// Update height array.
+		for (int k = tex_pos.x; k < tex_pos.x + mw; k++) {
+			tex.offsets.write[k] = tex_pos.y + mh;
+		}
+
+		chr.texture_idx = tex_pos.index;
+
+		chr.uv_rect = Rect2(tex_pos.x + p_rect_margin, tex_pos.y + p_rect_margin, w, h);
+		chr.rect.position = Vector2(bounds.l, -bounds.t);
+		chr.rect.size = chr.uv_rect.size;
+	}
+	return chr;
+}
+#endif
+
 #ifdef MODULE_FREETYPE_ENABLED
-	} else if (p_filename.get_extension() == "ttf" || p_filename.get_extension() == "otf" || p_filename.get_extension() == "woff") {
-		fd = memnew(DynamicFontDataFallback);
+_FORCE_INLINE_ TextServerFallback::FontGlyph TextServerFallback::rasterize_bitmap(FontDataForSizeFallback *p_data, int p_rect_margin, FT_Bitmap bitmap, int yofs, int xofs, const Vector2 &advance) const {
+	int w = bitmap.width;
+	int h = bitmap.rows;
+
+	int mw = w + p_rect_margin * 2;
+	int mh = h + p_rect_margin * 2;
+
+	ERR_FAIL_COND_V(mw > 4096, FontGlyph());
+	ERR_FAIL_COND_V(mh > 4096, FontGlyph());
+
+	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;
+
+	FontTexturePosition tex_pos = find_texture_pos_for_glyph(p_data, color_size, require_format, mw, mh);
+	ERR_FAIL_COND_V(tex_pos.index < 0, FontGlyph());
+
+	// Fit character in char texture.
+
+	FontTexture &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 + p_rect_margin) * tex.texture_w + j + tex_pos.x + p_rect_margin) * color_size;
+				ERR_FAIL_COND_V(ofs >= tex.imgdata.size(), FontGlyph());
+				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;
+					default:
+						ERR_FAIL_V_MSG(FontGlyph(), "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_w, tex.texture_h, 0, require_format, tex.imgdata));
+
+			if (tex.texture.is_null()) {
+				tex.texture.instantiate();
+				tex.texture->create_from_image(img);
+			} else {
+				tex.texture->update(img);
+			}
+		}
+	}
+
+	// Update height array.
+	for (int k = tex_pos.x; k < tex_pos.x + mw; k++) {
+		tex.offsets.write[k] = tex_pos.y + mh;
+	}
+
+	FontGlyph chr;
+	chr.advance = (advance * p_data->scale / p_data->oversampling).round();
+	chr.texture_idx = tex_pos.index;
+	chr.found = true;
+
+	chr.uv_rect = Rect2(tex_pos.x + p_rect_margin, tex_pos.y + p_rect_margin, w, h);
+	chr.rect.position = (Vector2(xofs, -yofs) * p_data->scale / p_data->oversampling).round();
+	chr.rect.size = chr.uv_rect.size * p_data->scale / p_data->oversampling;
+	return chr;
+}
 #endif
-	} else {
-		return RID();
+
+/*************************************************************************/
+/* Font Cache                                                            */
+/*************************************************************************/
+
+_FORCE_INLINE_ bool TextServerFallback::_ensure_glyph(FontDataFallback *p_font_data, const Vector2i &p_size, int32_t p_glyph) const {
+	ERR_FAIL_COND_V(!_ensure_cache_for_size(p_font_data, p_size), false);
+
+	FontDataForSizeFallback *fd = p_font_data->cache[p_size];
+	if (fd->glyph_map.has(p_glyph)) {
+		return fd->glyph_map[p_glyph].found;
 	}
 
-	Error err = fd->load_from_file(p_filename, p_base_size);
-	if (err != OK) {
-		memdelete(fd);
-		return RID();
+	if (p_glyph == 0) { // Non graphical or invalid glyph, do not render.
+		fd->glyph_map[p_glyph] = FontGlyph();
+		return true;
 	}
 
-	return font_owner.make_rid(fd);
+#ifdef MODULE_FREETYPE_ENABLED
+	FontGlyph gl;
+	if (fd->face) {
+		FT_Int32 flags = FT_LOAD_DEFAULT;
+
+		bool outline = p_size.y > 0;
+		switch (p_font_data->hinting) {
+			case TextServer::HINTING_NONE:
+				flags |= FT_LOAD_NO_HINTING;
+				break;
+			case TextServer::HINTING_LIGHT:
+				flags |= FT_LOAD_TARGET_LIGHT;
+				break;
+			default:
+				flags |= FT_LOAD_TARGET_NORMAL;
+				break;
+		}
+		if (p_font_data->force_autohinter) {
+			flags |= FT_LOAD_FORCE_AUTOHINT;
+		}
+		if (outline) {
+			flags |= FT_LOAD_NO_BITMAP;
+		} else if (FT_HAS_COLOR(fd->face)) {
+			flags |= FT_LOAD_COLOR;
+		}
+
+		FT_Fixed v, h;
+		FT_Get_Advance(fd->face, p_glyph, flags, &h);
+		FT_Get_Advance(fd->face, p_glyph, flags | FT_LOAD_VERTICAL_LAYOUT, &v);
+
+		int error = FT_Load_Glyph(fd->face, p_glyph, flags);
+		if (error) {
+			fd->glyph_map[p_glyph] = FontGlyph();
+			ERR_FAIL_V_MSG(false, "FreeType: Failed to load glyph.");
+		}
+
+		if (!outline) {
+			if (!p_font_data->msdf) {
+				error = FT_Render_Glyph(fd->face->glyph, p_font_data->antialiased ? FT_RENDER_MODE_NORMAL : FT_RENDER_MODE_MONO);
+			}
+			FT_GlyphSlot slot = fd->face->glyph;
+			if (!error) {
+				if (p_font_data->msdf) {
+#ifdef MODULE_MSDFGEN_ENABLED
+					gl = rasterize_msdf(p_font_data, fd, p_font_data->msdf_range, rect_range, &slot->outline, Vector2((h + (1 << 9)) >> 10, (v + (1 << 9)) >> 10) / 64.0);
+#else
+					fd->glyph_map[p_glyph] = FontGlyph();
+					ERR_FAIL_V_MSG(false, "Compiled without MSDFGEN support!");
+#endif
+				} else {
+					gl = rasterize_bitmap(fd, rect_range, slot->bitmap, slot->bitmap_top, slot->bitmap_left, Vector2((h + (1 << 9)) >> 10, (v + (1 << 9)) >> 10) / 64.0);
+				}
+			}
+		} else {
+			FT_Stroker stroker;
+			if (FT_Stroker_New(library, &stroker) != 0) {
+				fd->glyph_map[p_glyph] = FontGlyph();
+				ERR_FAIL_V_MSG(false, "FreeType: Failed to load glyph stroker.");
+			}
+
+			FT_Stroker_Set(stroker, (int)(fd->size.y * fd->oversampling * 16.0), FT_STROKER_LINECAP_BUTT, FT_STROKER_LINEJOIN_ROUND, 0);
+			FT_Glyph glyph;
+			FT_BitmapGlyph glyph_bitmap;
+
+			if (FT_Get_Glyph(fd->face->glyph, &glyph) != 0) {
+				goto cleanup_stroker;
+			}
+			if (FT_Glyph_Stroke(&glyph, stroker, 1) != 0) {
+				goto cleanup_glyph;
+			}
+			if (FT_Glyph_To_Bitmap(&glyph, p_font_data->antialiased ? FT_RENDER_MODE_NORMAL : FT_RENDER_MODE_MONO, nullptr, 1) != 0) {
+				goto cleanup_glyph;
+			}
+			glyph_bitmap = (FT_BitmapGlyph)glyph;
+			gl = rasterize_bitmap(fd, rect_range, glyph_bitmap->bitmap, glyph_bitmap->top, glyph_bitmap->left, Vector2());
+
+		cleanup_glyph:
+			FT_Done_Glyph(glyph);
+		cleanup_stroker:
+			FT_Stroker_Done(stroker);
+		}
+		fd->glyph_map[p_glyph] = gl;
+		return gl.found;
+	}
+#endif
+	fd->glyph_map[p_glyph] = FontGlyph();
+	return false;
 }
 
-RID TextServerFallback::create_font_memory(const uint8_t *p_data, size_t p_size, const String &p_type, int p_base_size) {
-	_THREAD_SAFE_METHOD_
-	FontDataFallback *fd = nullptr;
-	if (p_type == "fnt" || p_type == "font") {
-		fd = memnew(BitmapFontDataFallback);
+_FORCE_INLINE_ bool TextServerFallback::_ensure_cache_for_size(FontDataFallback *p_font_data, const Vector2i &p_size) const {
+	if (p_font_data->cache.has(p_size)) {
+		return true;
+	}
+
+	FontDataForSizeFallback *fd = memnew(FontDataForSizeFallback);
+	fd->size = p_size;
+	if (p_font_data->data_ptr) {
+		// Init dynamic font.
 #ifdef MODULE_FREETYPE_ENABLED
-	} else if (p_type == "ttf" || p_type == "otf" || p_type == "woff") {
-		fd = memnew(DynamicFontDataFallback);
+		int error = 0;
+		if (!library) {
+			error = FT_Init_FreeType(&library);
+			ERR_FAIL_COND_V_MSG(error != 0, false, TTR("FreeType: Error initializing library:") + " '" + String(FT_Error_String(error)) + "'.");
+		}
+
+		memset(&fd->stream, 0, sizeof(FT_StreamRec));
+		fd->stream.base = (unsigned char *)p_font_data->data_ptr;
+		fd->stream.size = p_font_data->data_size;
+		fd->stream.pos = 0;
+
+		FT_Open_Args fargs;
+		memset(&fargs, 0, sizeof(FT_Open_Args));
+		fargs.memory_base = (unsigned char *)p_font_data->data_ptr;
+		fargs.memory_size = p_font_data->data_size;
+		fargs.flags = FT_OPEN_MEMORY;
+		fargs.stream = &fd->stream;
+		error = FT_Open_Face(library, &fargs, 0, &fd->face);
+		if (error) {
+			FT_Done_Face(fd->face);
+			fd->face = nullptr;
+			ERR_FAIL_V_MSG(false, TTR("FreeType: Error loading font:") + " '" + String(FT_Error_String(error)) + "'.");
+		}
+
+		if (p_font_data->msdf) {
+			fd->oversampling = 1.0f;
+			fd->size.x = p_font_data->msdf_source_size;
+		} else if (p_font_data->oversampling <= 0.0f) {
+			fd->oversampling = TS->font_get_global_oversampling();
+		} else {
+			fd->oversampling = p_font_data->oversampling;
+		}
+
+		if (FT_HAS_COLOR(fd->face) && fd->face->num_fixed_sizes > 0) {
+			int best_match = 0;
+			int diff = ABS(fd->size.x - ((int64_t)fd->face->available_sizes[0].width));
+			fd->scale = real_t(fd->size.x * fd->oversampling) / fd->face->available_sizes[0].width;
+			for (int i = 1; i < fd->face->num_fixed_sizes; i++) {
+				int ndiff = ABS(fd->size.x - ((int64_t)fd->face->available_sizes[i].width));
+				if (ndiff < diff) {
+					best_match = i;
+					diff = ndiff;
+					fd->scale = real_t(fd->size.x * fd->oversampling) / fd->face->available_sizes[i].width;
+				}
+			}
+			FT_Select_Size(fd->face, best_match);
+		} else {
+			FT_Set_Pixel_Sizes(fd->face, 0, fd->size.x * fd->oversampling);
+		}
+
+		fd->ascent = (fd->face->size->metrics.ascender / 64.0) / fd->oversampling * fd->scale;
+		fd->descent = (-fd->face->size->metrics.descender / 64.0) / fd->oversampling * fd->scale;
+		fd->underline_position = (-FT_MulFix(fd->face->underline_position, fd->face->size->metrics.y_scale) / 64.0) / fd->oversampling * fd->scale;
+		fd->underline_thickness = (FT_MulFix(fd->face->underline_thickness, fd->face->size->metrics.y_scale) / 64.0) / fd->oversampling * fd->scale;
+
+		if (!p_font_data->face_init) {
+			// Read OpenType variations.
+			p_font_data->supported_varaitions.clear();
+			if (fd->face->face_flags & FT_FACE_FLAG_MULTIPLE_MASTERS) {
+				FT_MM_Var *amaster;
+				FT_Get_MM_Var(fd->face, &amaster);
+				for (FT_UInt i = 0; i < amaster->num_axis; i++) {
+					p_font_data->supported_varaitions[(int32_t)amaster->axis[i].tag] = Vector3i(amaster->axis[i].minimum / 65536, amaster->axis[i].maximum / 65536, amaster->axis[i].def / 65536);
+				}
+				FT_Done_MM_Var(library, amaster);
+			}
+			p_font_data->face_init = true;
+		}
+
+		// Write variations.
+		if (fd->face->face_flags & FT_FACE_FLAG_MULTIPLE_MASTERS) {
+			FT_MM_Var *amaster;
+
+			FT_Get_MM_Var(fd->face, &amaster);
+
+			Vector<FT_Fixed> coords;
+			coords.resize(amaster->num_axis);
+
+			FT_Get_Var_Design_Coordinates(fd->face, coords.size(), coords.ptrw());
+
+			for (FT_UInt i = 0; i < amaster->num_axis; i++) {
+				// Reset to default.
+				int32_t var_tag = amaster->axis[i].tag;
+				real_t var_value = (double)amaster->axis[i].def / 65536.f;
+				coords.write[i] = amaster->axis[i].def;
+
+				if (p_font_data->variation_coordinates.has(var_tag)) {
+					var_value = p_font_data->variation_coordinates[var_tag];
+					coords.write[i] = CLAMP(var_value * 65536.f, amaster->axis[i].minimum, amaster->axis[i].maximum);
+				}
+
+				if (p_font_data->variation_coordinates.has(tag_to_name(var_tag))) {
+					var_value = p_font_data->variation_coordinates[tag_to_name(var_tag)];
+					coords.write[i] = CLAMP(var_value * 65536.f, amaster->axis[i].minimum, amaster->axis[i].maximum);
+				}
+			}
+
+			FT_Set_Var_Design_Coordinates(fd->face, coords.size(), coords.ptrw());
+			FT_Done_MM_Var(library, amaster);
+		}
+#else
+		ERR_FAIL_V_MSG(false, TTR("FreeType: Can't load dynamic font, engine is compiled without FreeType support!");
 #endif
-	} else {
-		return RID();
 	}
+	p_font_data->cache[p_size] = fd;
+	return true;
+}
 
-	Error err = fd->load_from_memory(p_data, p_size, p_base_size);
-	if (err != OK) {
-		memdelete(fd);
-		return RID();
+_FORCE_INLINE_ void TextServerFallback::_font_clear_cache(FontDataFallback *p_font_data) {
+	for (const Map<Vector2i, FontDataForSizeFallback *>::Element *E = p_font_data->cache.front(); E; E = E->next()) {
+		memdelete(E->get());
 	}
 
+	p_font_data->cache.clear();
+	p_font_data->face_init = false;
+	p_font_data->supported_varaitions.clear();
+}
+
+RID TextServerFallback::create_font() {
+	FontDataFallback *fd = memnew(FontDataFallback);
+
 	return font_owner.make_rid(fd);
 }
 
-RID TextServerFallback::create_font_bitmap(float p_height, float p_ascent, int p_base_size) {
-	_THREAD_SAFE_METHOD_
-	FontDataFallback *fd = memnew(BitmapFontDataFallback);
-	Error err = fd->bitmap_new(p_height, p_ascent, p_base_size);
-	if (err != OK) {
-		memdelete(fd);
-		return RID();
+void TextServerFallback::font_set_data(RID p_font_rid, const PackedByteArray &p_data) {
+	FontDataFallback *fd = font_owner.getornull(p_font_rid);
+	ERR_FAIL_COND(!fd);
+
+	MutexLock lock(fd->mutex);
+	_font_clear_cache(fd);
+	fd->data = p_data;
+	fd->data_ptr = fd->data.ptr();
+	fd->data_size = fd->data.size();
+}
+
+void TextServerFallback::font_set_data_ptr(RID p_font_rid, const uint8_t *p_data_ptr, size_t p_data_size) {
+	FontDataFallback *fd = font_owner.getornull(p_font_rid);
+	ERR_FAIL_COND(!fd);
+
+	MutexLock lock(fd->mutex);
+	_font_clear_cache(fd);
+	fd->data.clear();
+	fd->data_ptr = p_data_ptr;
+	fd->data_size = p_data_size;
+}
+
+void TextServerFallback::font_set_antialiased(RID p_font_rid, bool p_antialiased) {
+	FontDataFallback *fd = font_owner.getornull(p_font_rid);
+	ERR_FAIL_COND(!fd);
+
+	MutexLock lock(fd->mutex);
+	if (fd->antialiased != p_antialiased) {
+		_font_clear_cache(fd);
+		fd->antialiased = p_antialiased;
 	}
+}
 
-	return font_owner.make_rid(fd);
+bool TextServerFallback::font_is_antialiased(RID p_font_rid) const {
+	FontDataFallback *fd = font_owner.getornull(p_font_rid);
+	ERR_FAIL_COND_V(!fd, false);
+
+	MutexLock lock(fd->mutex);
+	return fd->antialiased;
 }
 
-void TextServerFallback::font_bitmap_add_texture(RID p_font, const Ref<Texture> &p_texture) {
-	_THREAD_SAFE_METHOD_
-	FontDataFallback *fd = font_owner.getornull(p_font);
+void TextServerFallback::font_set_multichannel_signed_distance_field(RID p_font_rid, bool p_msdf) {
+	FontDataFallback *fd = font_owner.getornull(p_font_rid);
 	ERR_FAIL_COND(!fd);
-	fd->bitmap_add_texture(p_texture);
+
+	MutexLock lock(fd->mutex);
+	if (fd->msdf != p_msdf) {
+		_font_clear_cache(fd);
+		fd->msdf = p_msdf;
+	}
 }
 
-void TextServerFallback::font_bitmap_add_char(RID p_font, char32_t p_char, int p_texture_idx, const Rect2 &p_rect, const Size2 &p_align, float p_advance) {
-	_THREAD_SAFE_METHOD_
-	FontDataFallback *fd = font_owner.getornull(p_font);
+bool TextServerFallback::font_is_multichannel_signed_distance_field(RID p_font_rid) const {
+	FontDataFallback *fd = font_owner.getornull(p_font_rid);
+	ERR_FAIL_COND_V(!fd, false);
+
+	MutexLock lock(fd->mutex);
+	return fd->msdf;
+}
+
+void TextServerFallback::font_set_msdf_pixel_range(RID p_font_rid, int p_msdf_pixel_range) {
+	FontDataFallback *fd = font_owner.getornull(p_font_rid);
 	ERR_FAIL_COND(!fd);
-	fd->bitmap_add_char(p_char, p_texture_idx, p_rect, p_align, p_advance);
+
+	MutexLock lock(fd->mutex);
+	if (fd->msdf_range != p_msdf_pixel_range) {
+		_font_clear_cache(fd);
+		fd->msdf_range = p_msdf_pixel_range;
+	}
 }
 
-void TextServerFallback::font_bitmap_add_kerning_pair(RID p_font, char32_t p_A, char32_t p_B, int p_kerning) {
-	_THREAD_SAFE_METHOD_
-	FontDataFallback *fd = font_owner.getornull(p_font);
+int TextServerFallback::font_get_msdf_pixel_range(RID p_font_rid) const {
+	FontDataFallback *fd = font_owner.getornull(p_font_rid);
+	ERR_FAIL_COND_V(!fd, false);
+
+	MutexLock lock(fd->mutex);
+	return fd->msdf_range;
+}
+
+void TextServerFallback::font_set_msdf_size(RID p_font_rid, int p_msdf_size) {
+	FontDataFallback *fd = font_owner.getornull(p_font_rid);
 	ERR_FAIL_COND(!fd);
-	fd->bitmap_add_kerning_pair(p_A, p_B, p_kerning);
+
+	MutexLock lock(fd->mutex);
+	if (fd->msdf_source_size != p_msdf_size) {
+		_font_clear_cache(fd);
+		fd->msdf_source_size = p_msdf_size;
+	}
 }
 
-float TextServerFallback::font_get_height(RID p_font, int p_size) const {
-	_THREAD_SAFE_METHOD_
-	const FontDataFallback *fd = font_owner.getornull(p_font);
+int TextServerFallback::font_get_msdf_size(RID p_font_rid) const {
+	FontDataFallback *fd = font_owner.getornull(p_font_rid);
+	ERR_FAIL_COND_V(!fd, false);
+
+	MutexLock lock(fd->mutex);
+	return fd->msdf_source_size;
+}
+
+void TextServerFallback::font_set_fixed_size(RID p_font_rid, int p_fixed_size) {
+	FontDataFallback *fd = font_owner.getornull(p_font_rid);
+	ERR_FAIL_COND(!fd);
+
+	MutexLock lock(fd->mutex);
+	if (fd->fixed_size != p_fixed_size) {
+		fd->fixed_size = p_fixed_size;
+	}
+}
+
+int TextServerFallback::font_get_fixed_size(RID p_font_rid) const {
+	FontDataFallback *fd = font_owner.getornull(p_font_rid);
+	ERR_FAIL_COND_V(!fd, false);
+
+	MutexLock lock(fd->mutex);
+	return fd->fixed_size;
+}
+
+void TextServerFallback::font_set_force_autohinter(RID p_font_rid, bool p_force_autohinter) {
+	FontDataFallback *fd = font_owner.getornull(p_font_rid);
+	ERR_FAIL_COND(!fd);
+
+	MutexLock lock(fd->mutex);
+	if (fd->force_autohinter != p_force_autohinter) {
+		_font_clear_cache(fd);
+		fd->force_autohinter = p_force_autohinter;
+	}
+}
+
+bool TextServerFallback::font_is_force_autohinter(RID p_font_rid) const {
+	FontDataFallback *fd = font_owner.getornull(p_font_rid);
+	ERR_FAIL_COND_V(!fd, false);
+
+	MutexLock lock(fd->mutex);
+	return fd->force_autohinter;
+}
+
+void TextServerFallback::font_set_hinting(RID p_font_rid, TextServer::Hinting p_hinting) {
+	FontDataFallback *fd = font_owner.getornull(p_font_rid);
+	ERR_FAIL_COND(!fd);
+
+	MutexLock lock(fd->mutex);
+	if (fd->hinting != p_hinting) {
+		_font_clear_cache(fd);
+		fd->hinting = p_hinting;
+	}
+}
+
+TextServer::Hinting TextServerFallback::font_get_hinting(RID p_font_rid) const {
+	FontDataFallback *fd = font_owner.getornull(p_font_rid);
+	ERR_FAIL_COND_V(!fd, HINTING_NONE);
+
+	MutexLock lock(fd->mutex);
+	return fd->hinting;
+}
+
+void TextServerFallback::font_set_variation_coordinates(RID p_font_rid, const Dictionary &p_variation_coordinates) {
+	FontDataFallback *fd = font_owner.getornull(p_font_rid);
+	ERR_FAIL_COND(!fd);
+
+	MutexLock lock(fd->mutex);
+	if (fd->variation_coordinates != p_variation_coordinates) {
+		_font_clear_cache(fd);
+		fd->variation_coordinates = p_variation_coordinates;
+	}
+}
+
+Dictionary TextServerFallback::font_get_variation_coordinates(RID p_font_rid) const {
+	FontDataFallback *fd = font_owner.getornull(p_font_rid);
+	ERR_FAIL_COND_V(!fd, Dictionary());
+
+	MutexLock lock(fd->mutex);
+	return fd->variation_coordinates;
+}
+
+void TextServerFallback::font_set_oversampling(RID p_font_rid, real_t p_oversampling) {
+	FontDataFallback *fd = font_owner.getornull(p_font_rid);
+	ERR_FAIL_COND(!fd);
+
+	MutexLock lock(fd->mutex);
+	if (fd->oversampling != p_oversampling) {
+		_font_clear_cache(fd);
+		fd->oversampling = p_oversampling;
+	}
+}
+
+real_t TextServerFallback::font_get_oversampling(RID p_font_rid) const {
+	FontDataFallback *fd = font_owner.getornull(p_font_rid);
 	ERR_FAIL_COND_V(!fd, 0.f);
-	return fd->get_height(p_size);
+
+	MutexLock lock(fd->mutex);
+	return fd->oversampling;
 }
 
-float TextServerFallback::font_get_ascent(RID p_font, int p_size) const {
-	_THREAD_SAFE_METHOD_
-	const FontDataFallback *fd = font_owner.getornull(p_font);
+Array TextServerFallback::font_get_size_cache_list(RID p_font_rid) const {
+	FontDataFallback *fd = font_owner.getornull(p_font_rid);
+	ERR_FAIL_COND_V(!fd, Array());
+
+	MutexLock lock(fd->mutex);
+	Array ret;
+	for (const Map<Vector2i, FontDataForSizeFallback *>::Element *E = fd->cache.front(); E; E = E->next()) {
+		ret.push_back(E->key());
+	}
+	return ret;
+}
+
+void TextServerFallback::font_clear_size_cache(RID p_font_rid) {
+	FontDataFallback *fd = font_owner.getornull(p_font_rid);
+	ERR_FAIL_COND(!fd);
+
+	MutexLock lock(fd->mutex);
+	for (const Map<Vector2i, FontDataForSizeFallback *>::Element *E = fd->cache.front(); E; E = E->next()) {
+		memdelete(E->get());
+	}
+	fd->cache.clear();
+}
+
+void TextServerFallback::font_remove_size_cache(RID p_font_rid, const Vector2i &p_size) {
+	FontDataFallback *fd = font_owner.getornull(p_font_rid);
+	ERR_FAIL_COND(!fd);
+
+	MutexLock lock(fd->mutex);
+	if (fd->cache.has(p_size)) {
+		memdelete(fd->cache[p_size]);
+		fd->cache.erase(p_size);
+	}
+}
+
+void TextServerFallback::font_set_ascent(RID p_font_rid, int p_size, real_t p_ascent) {
+	FontDataFallback *fd = font_owner.getornull(p_font_rid);
+	ERR_FAIL_COND(!fd);
+
+	MutexLock lock(fd->mutex);
+	Vector2i size = _get_size(fd, p_size);
+
+	ERR_FAIL_COND(!_ensure_cache_for_size(fd, size));
+	fd->cache[size]->ascent = p_ascent;
+}
+
+real_t TextServerFallback::font_get_ascent(RID p_font_rid, int p_size) const {
+	FontDataFallback *fd = font_owner.getornull(p_font_rid);
 	ERR_FAIL_COND_V(!fd, 0.f);
-	return fd->get_ascent(p_size);
+
+	MutexLock lock(fd->mutex);
+	Vector2i size = _get_size(fd, p_size);
+
+	ERR_FAIL_COND_V(!_ensure_cache_for_size(fd, size), 0.f);
+
+	if (fd->msdf) {
+		return fd->cache[size]->ascent * (real_t)p_size / (real_t)fd->msdf_source_size;
+	} else {
+		return fd->cache[size]->ascent;
+	}
 }
 
-float TextServerFallback::font_get_descent(RID p_font, int p_size) const {
-	_THREAD_SAFE_METHOD_
-	const FontDataFallback *fd = font_owner.getornull(p_font);
+void TextServerFallback::font_set_descent(RID p_font_rid, int p_size, real_t p_descent) {
+	FontDataFallback *fd = font_owner.getornull(p_font_rid);
+	ERR_FAIL_COND(!fd);
+
+	Vector2i size = _get_size(fd, p_size);
+
+	ERR_FAIL_COND(!_ensure_cache_for_size(fd, size));
+	fd->cache[size]->descent = p_descent;
+}
+
+real_t TextServerFallback::font_get_descent(RID p_font_rid, int p_size) const {
+	FontDataFallback *fd = font_owner.getornull(p_font_rid);
 	ERR_FAIL_COND_V(!fd, 0.f);
-	return fd->get_descent(p_size);
+
+	MutexLock lock(fd->mutex);
+	Vector2i size = _get_size(fd, p_size);
+
+	ERR_FAIL_COND_V(!_ensure_cache_for_size(fd, size), 0.f);
+
+	if (fd->msdf) {
+		return fd->cache[size]->descent * (real_t)p_size / (real_t)fd->msdf_source_size;
+	} else {
+		return fd->cache[size]->descent;
+	}
 }
 
-float TextServerFallback::font_get_underline_position(RID p_font, int p_size) const {
-	_THREAD_SAFE_METHOD_
-	const FontDataFallback *fd = font_owner.getornull(p_font);
+void TextServerFallback::font_set_underline_position(RID p_font_rid, int p_size, real_t p_underline_position) {
+	FontDataFallback *fd = font_owner.getornull(p_font_rid);
+	ERR_FAIL_COND(!fd);
+
+	MutexLock lock(fd->mutex);
+	Vector2i size = _get_size(fd, p_size);
+
+	ERR_FAIL_COND(!_ensure_cache_for_size(fd, size));
+	fd->cache[size]->underline_position = p_underline_position;
+}
+
+real_t TextServerFallback::font_get_underline_position(RID p_font_rid, int p_size) const {
+	FontDataFallback *fd = font_owner.getornull(p_font_rid);
 	ERR_FAIL_COND_V(!fd, 0.f);
-	return fd->get_underline_position(p_size);
+
+	MutexLock lock(fd->mutex);
+	Vector2i size = _get_size(fd, p_size);
+
+	ERR_FAIL_COND_V(!_ensure_cache_for_size(fd, size), 0.f);
+
+	if (fd->msdf) {
+		return fd->cache[size]->underline_position * (real_t)p_size / (real_t)fd->msdf_source_size;
+	} else {
+		return fd->cache[size]->underline_position;
+	}
 }
 
-float TextServerFallback::font_get_underline_thickness(RID p_font, int p_size) const {
-	_THREAD_SAFE_METHOD_
-	const FontDataFallback *fd = font_owner.getornull(p_font);
+void TextServerFallback::font_set_underline_thickness(RID p_font_rid, int p_size, real_t p_underline_thickness) {
+	FontDataFallback *fd = font_owner.getornull(p_font_rid);
+	ERR_FAIL_COND(!fd);
+
+	MutexLock lock(fd->mutex);
+	Vector2i size = _get_size(fd, p_size);
+
+	ERR_FAIL_COND(!_ensure_cache_for_size(fd, size));
+	fd->cache[size]->underline_thickness = p_underline_thickness;
+}
+
+real_t TextServerFallback::font_get_underline_thickness(RID p_font_rid, int p_size) const {
+	FontDataFallback *fd = font_owner.getornull(p_font_rid);
 	ERR_FAIL_COND_V(!fd, 0.f);
-	return fd->get_underline_thickness(p_size);
+
+	MutexLock lock(fd->mutex);
+	Vector2i size = _get_size(fd, p_size);
+
+	ERR_FAIL_COND_V(!_ensure_cache_for_size(fd, size), 0.f);
+
+	if (fd->msdf) {
+		return fd->cache[size]->underline_thickness * (real_t)p_size / (real_t)fd->msdf_source_size;
+	} else {
+		return fd->cache[size]->underline_thickness;
+	}
 }
 
-int TextServerFallback::font_get_spacing_space(RID p_font) const {
-	_THREAD_SAFE_METHOD_
-	const FontDataFallback *fd = font_owner.getornull(p_font);
-	ERR_FAIL_COND_V(!fd, 0);
-	return fd->get_spacing_space();
+void TextServerFallback::font_set_scale(RID p_font_rid, int p_size, real_t p_scale) {
+	FontDataFallback *fd = font_owner.getornull(p_font_rid);
+	ERR_FAIL_COND(!fd);
+
+	MutexLock lock(fd->mutex);
+	Vector2i size = _get_size(fd, p_size);
+
+	ERR_FAIL_COND(!_ensure_cache_for_size(fd, size));
+	fd->cache[size]->scale = p_scale;
 }
 
-void TextServerFallback::font_set_spacing_space(RID p_font, int p_value) {
-	_THREAD_SAFE_METHOD_
-	FontDataFallback *fd = font_owner.getornull(p_font);
+real_t TextServerFallback::font_get_scale(RID p_font_rid, int p_size) const {
+	FontDataFallback *fd = font_owner.getornull(p_font_rid);
+	ERR_FAIL_COND_V(!fd, 0.f);
+
+	MutexLock lock(fd->mutex);
+	Vector2i size = _get_size(fd, p_size);
+
+	ERR_FAIL_COND_V(!_ensure_cache_for_size(fd, size), 0.f);
+
+	if (fd->msdf) {
+		return fd->cache[size]->scale * (real_t)p_size / (real_t)fd->msdf_source_size;
+	} else {
+		return fd->cache[size]->scale / fd->cache[size]->oversampling;
+	}
+}
+
+void TextServerFallback::font_set_spacing(RID p_font_rid, int p_size, TextServer::SpacingType p_spacing, int p_value) {
+	FontDataFallback *fd = font_owner.getornull(p_font_rid);
 	ERR_FAIL_COND(!fd);
-	fd->set_spacing_space(p_value);
+
+	MutexLock lock(fd->mutex);
+	Vector2i size = _get_size(fd, p_size);
+
+	ERR_FAIL_COND(!_ensure_cache_for_size(fd, size));
+	switch (p_spacing) {
+		case TextServer::SPACING_GLYPH: {
+			fd->cache[size]->spacing_glyph = p_value;
+		} break;
+		case TextServer::SPACING_SPACE: {
+			fd->cache[size]->spacing_space = p_value;
+		} break;
+		default: {
+			ERR_FAIL_MSG("Invalid spacing type: " + itos(p_spacing));
+		} break;
+	}
 }
 
-int TextServerFallback::font_get_spacing_glyph(RID p_font) const {
-	_THREAD_SAFE_METHOD_
-	const FontDataFallback *fd = font_owner.getornull(p_font);
+int TextServerFallback::font_get_spacing(RID p_font_rid, int p_size, TextServer::SpacingType p_spacing) const {
+	FontDataFallback *fd = font_owner.getornull(p_font_rid);
+	ERR_FAIL_COND_V(!fd, 0);
+
+	MutexLock lock(fd->mutex);
+	Vector2i size = _get_size(fd, p_size);
+
+	ERR_FAIL_COND_V(!_ensure_cache_for_size(fd, size), 0);
+
+	switch (p_spacing) {
+		case TextServer::SPACING_GLYPH: {
+			if (fd->msdf) {
+				return fd->cache[size]->spacing_glyph * (real_t)p_size / (real_t)fd->msdf_source_size;
+			} else {
+				return fd->cache[size]->spacing_glyph;
+			}
+		} break;
+		case TextServer::SPACING_SPACE: {
+			if (fd->msdf) {
+				return fd->cache[size]->spacing_space * (real_t)p_size / (real_t)fd->msdf_source_size;
+			} else {
+				return fd->cache[size]->spacing_space;
+			}
+		} break;
+		default: {
+			ERR_FAIL_V_MSG(0, "Invalid spacing type: " + itos(p_spacing));
+		} break;
+	}
+	return 0;
+}
+
+int TextServerFallback::font_get_texture_count(RID p_font_rid, const Vector2i &p_size) const {
+	FontDataFallback *fd = font_owner.getornull(p_font_rid);
 	ERR_FAIL_COND_V(!fd, 0);
-	return fd->get_spacing_glyph();
+
+	MutexLock lock(fd->mutex);
+	Vector2i size = _get_size_outline(fd, p_size);
+
+	ERR_FAIL_COND_V(!_ensure_cache_for_size(fd, size), 0);
+
+	return fd->cache[size]->textures.size();
 }
 
-void TextServerFallback::font_set_spacing_glyph(RID p_font, int p_value) {
-	_THREAD_SAFE_METHOD_
-	FontDataFallback *fd = font_owner.getornull(p_font);
+void TextServerFallback::font_clear_textures(RID p_font_rid, const Vector2i &p_size) {
+	FontDataFallback *fd = font_owner.getornull(p_font_rid);
 	ERR_FAIL_COND(!fd);
-	fd->set_spacing_glyph(p_value);
+	MutexLock lock(fd->mutex);
+	Vector2i size = _get_size_outline(fd, p_size);
+
+	ERR_FAIL_COND(!_ensure_cache_for_size(fd, size));
+	fd->cache[size]->textures.clear();
 }
 
-void TextServerFallback::font_set_antialiased(RID p_font, bool p_antialiased) {
-	_THREAD_SAFE_METHOD_
-	FontDataFallback *fd = font_owner.getornull(p_font);
+void TextServerFallback::font_remove_texture(RID p_font_rid, const Vector2i &p_size, int p_texture_index) {
+	FontDataFallback *fd = font_owner.getornull(p_font_rid);
 	ERR_FAIL_COND(!fd);
-	fd->set_antialiased(p_antialiased);
+
+	MutexLock lock(fd->mutex);
+	Vector2i size = _get_size_outline(fd, p_size);
+	ERR_FAIL_COND(!_ensure_cache_for_size(fd, size));
+	ERR_FAIL_INDEX(p_texture_index, fd->cache[size]->textures.size());
+
+	fd->cache[size]->textures.remove(p_texture_index);
 }
 
-bool TextServerFallback::font_get_antialiased(RID p_font) const {
-	_THREAD_SAFE_METHOD_
-	const FontDataFallback *fd = font_owner.getornull(p_font);
-	ERR_FAIL_COND_V(!fd, false);
-	return fd->get_antialiased();
+void TextServerFallback::font_set_texture_image(RID p_font_rid, const Vector2i &p_size, int p_texture_index, const Ref<Image> &p_image) {
+	FontDataFallback *fd = font_owner.getornull(p_font_rid);
+	ERR_FAIL_COND(!fd);
+	ERR_FAIL_COND(p_image.is_null());
+
+	MutexLock lock(fd->mutex);
+	Vector2i size = _get_size_outline(fd, p_size);
+	ERR_FAIL_COND(!_ensure_cache_for_size(fd, size));
+	ERR_FAIL_COND(p_texture_index < 0);
+	if (p_texture_index >= fd->cache[size]->textures.size()) {
+		fd->cache[size]->textures.resize(p_texture_index + 1);
+	}
+
+	FontTexture &tex = fd->cache[size]->textures.write[p_texture_index];
+
+	tex.imgdata = p_image->get_data();
+	tex.texture_w = p_image->get_width();
+	tex.texture_h = p_image->get_height();
+	tex.format = p_image->get_format();
+
+	Ref<Image> img = memnew(Image(tex.texture_w, tex.texture_h, 0, tex.format, tex.imgdata));
+	tex.texture = Ref<ImageTexture>();
+	tex.texture.instantiate();
+	tex.texture->create_from_image(img);
 }
 
-void TextServerFallback::font_set_distance_field_hint(RID p_font, bool p_distance_field) {
-	_THREAD_SAFE_METHOD_
-	FontDataFallback *fd = font_owner.getornull(p_font);
+Ref<Image> TextServerFallback::font_get_texture_image(RID p_font_rid, const Vector2i &p_size, int p_texture_index) const {
+	FontDataFallback *fd = font_owner.getornull(p_font_rid);
+	ERR_FAIL_COND_V(!fd, Ref<Image>());
+
+	MutexLock lock(fd->mutex);
+	Vector2i size = _get_size_outline(fd, p_size);
+	ERR_FAIL_COND_V(!_ensure_cache_for_size(fd, size), Ref<Image>());
+	ERR_FAIL_INDEX_V(p_texture_index, fd->cache[size]->textures.size(), Ref<Image>());
+
+	const FontTexture &tex = fd->cache[size]->textures.write[p_texture_index];
+	Ref<Image> img = memnew(Image(tex.texture_w, tex.texture_h, 0, tex.format, tex.imgdata));
+
+	return img;
+}
+
+void TextServerFallback::font_set_texture_offsets(RID p_font_rid, const Vector2i &p_size, int p_texture_index, const PackedInt32Array &p_offset) {
+	FontDataFallback *fd = font_owner.getornull(p_font_rid);
 	ERR_FAIL_COND(!fd);
-	fd->set_distance_field_hint(p_distance_field);
+
+	MutexLock lock(fd->mutex);
+	Vector2i size = _get_size_outline(fd, p_size);
+	ERR_FAIL_COND(!_ensure_cache_for_size(fd, size));
+	if (p_texture_index >= fd->cache[size]->textures.size()) {
+		fd->cache[size]->textures.resize(p_texture_index + 1);
+	}
+
+	FontTexture &tex = fd->cache[size]->textures.write[p_texture_index];
+	tex.offsets = p_offset;
 }
 
-bool TextServerFallback::font_get_distance_field_hint(RID p_font) const {
-	_THREAD_SAFE_METHOD_
-	const FontDataFallback *fd = font_owner.getornull(p_font);
-	ERR_FAIL_COND_V(!fd, false);
-	return fd->get_distance_field_hint();
+PackedInt32Array TextServerFallback::font_get_texture_offsets(RID p_font_rid, const Vector2i &p_size, int p_texture_index) const {
+	FontDataFallback *fd = font_owner.getornull(p_font_rid);
+	ERR_FAIL_COND_V(!fd, PackedInt32Array());
+
+	MutexLock lock(fd->mutex);
+	Vector2i size = _get_size_outline(fd, p_size);
+	ERR_FAIL_COND_V(!_ensure_cache_for_size(fd, size), PackedInt32Array());
+	ERR_FAIL_INDEX_V(p_texture_index, fd->cache[size]->textures.size(), PackedInt32Array());
+
+	const FontTexture &tex = fd->cache[size]->textures.write[p_texture_index];
+	return tex.offsets;
 }
 
-void TextServerFallback::font_set_hinting(RID p_font, TextServer::Hinting p_hinting) {
-	_THREAD_SAFE_METHOD_
-	FontDataFallback *fd = font_owner.getornull(p_font);
+Array TextServerFallback::font_get_glyph_list(RID p_font_rid, const Vector2i &p_size) const {
+	FontDataFallback *fd = font_owner.getornull(p_font_rid);
+	ERR_FAIL_COND_V(!fd, Array());
+
+	MutexLock lock(fd->mutex);
+	Vector2i size = _get_size_outline(fd, p_size);
+	ERR_FAIL_COND_V(!_ensure_cache_for_size(fd, size), Array());
+
+	Array ret;
+	const HashMap<int32_t, FontGlyph> &gl = fd->cache[size]->glyph_map;
+	const int32_t *E = nullptr;
+	while ((E = gl.next(E))) {
+		ret.push_back(*E);
+	}
+	return ret;
+}
+
+void TextServerFallback::font_clear_glyphs(RID p_font_rid, const Vector2i &p_size) {
+	FontDataFallback *fd = font_owner.getornull(p_font_rid);
 	ERR_FAIL_COND(!fd);
-	fd->set_hinting(p_hinting);
+
+	MutexLock lock(fd->mutex);
+	Vector2i size = _get_size_outline(fd, p_size);
+	ERR_FAIL_COND(!_ensure_cache_for_size(fd, size));
+
+	fd->cache[size]->glyph_map.clear();
 }
 
-TextServer::Hinting TextServerFallback::font_get_hinting(RID p_font) const {
-	_THREAD_SAFE_METHOD_
-	const FontDataFallback *fd = font_owner.getornull(p_font);
-	ERR_FAIL_COND_V(!fd, TextServer::HINTING_NONE);
-	return fd->get_hinting();
+void TextServerFallback::font_remove_glyph(RID p_font_rid, const Vector2i &p_size, int32_t p_glyph) {
+	FontDataFallback *fd = font_owner.getornull(p_font_rid);
+	ERR_FAIL_COND(!fd);
+
+	MutexLock lock(fd->mutex);
+	Vector2i size = _get_size_outline(fd, p_size);
+	ERR_FAIL_COND(!_ensure_cache_for_size(fd, size));
+
+	fd->cache[size]->glyph_map.erase(p_glyph);
 }
 
-void TextServerFallback::font_set_force_autohinter(RID p_font, bool p_enabeld) {
-	_THREAD_SAFE_METHOD_
-	FontDataFallback *fd = font_owner.getornull(p_font);
+Vector2 TextServerFallback::font_get_glyph_advance(RID p_font_rid, int p_size, int32_t p_glyph) const {
+	FontDataFallback *fd = font_owner.getornull(p_font_rid);
+	ERR_FAIL_COND_V(!fd, Vector2());
+
+	MutexLock lock(fd->mutex);
+	Vector2i size = _get_size(fd, p_size);
+
+	ERR_FAIL_COND_V(!_ensure_cache_for_size(fd, size), Vector2());
+	if (!_ensure_glyph(fd, size, p_glyph)) {
+		return Vector2(); // Invalid or non graphicl glyph, do not display errors.
+	}
+
+	const HashMap<int32_t, FontGlyph> &gl = fd->cache[size]->glyph_map;
+
+	if (fd->msdf) {
+		return gl[p_glyph].advance * (real_t)p_size / (real_t)fd->msdf_source_size;
+	} else {
+		return gl[p_glyph].advance;
+	}
+}
+
+void TextServerFallback::font_set_glyph_advance(RID p_font_rid, int p_size, int32_t p_glyph, const Vector2 &p_advance) {
+	FontDataFallback *fd = font_owner.getornull(p_font_rid);
 	ERR_FAIL_COND(!fd);
-	fd->set_force_autohinter(p_enabeld);
+
+	MutexLock lock(fd->mutex);
+	Vector2i size = _get_size(fd, p_size);
+
+	ERR_FAIL_COND(!_ensure_cache_for_size(fd, size));
+
+	HashMap<int32_t, FontGlyph> &gl = fd->cache[size]->glyph_map;
+
+	gl[p_glyph].advance = p_advance;
+	gl[p_glyph].found = true;
 }
 
-bool TextServerFallback::font_get_force_autohinter(RID p_font) const {
-	_THREAD_SAFE_METHOD_
-	const FontDataFallback *fd = font_owner.getornull(p_font);
+Vector2 TextServerFallback::font_get_glyph_offset(RID p_font_rid, const Vector2i &p_size, int32_t p_glyph) const {
+	FontDataFallback *fd = font_owner.getornull(p_font_rid);
+	ERR_FAIL_COND_V(!fd, Vector2());
+
+	MutexLock lock(fd->mutex);
+	Vector2i size = _get_size_outline(fd, p_size);
+
+	ERR_FAIL_COND_V(!_ensure_cache_for_size(fd, size), Vector2());
+	if (!_ensure_glyph(fd, size, p_glyph)) {
+		return Vector2(); // Invalid or non graphicl glyph, do not display errors.
+	}
+
+	const HashMap<int32_t, FontGlyph> &gl = fd->cache[size]->glyph_map;
+
+	if (fd->msdf) {
+		return gl[p_glyph].rect.position * (real_t)p_size.x / (real_t)fd->msdf_source_size;
+	} else {
+		return gl[p_glyph].rect.position;
+	}
+}
+
+void TextServerFallback::font_set_glyph_offset(RID p_font_rid, const Vector2i &p_size, int32_t p_glyph, const Vector2 &p_offset) {
+	FontDataFallback *fd = font_owner.getornull(p_font_rid);
+	ERR_FAIL_COND(!fd);
+
+	MutexLock lock(fd->mutex);
+	Vector2i size = _get_size_outline(fd, p_size);
+
+	ERR_FAIL_COND(!_ensure_cache_for_size(fd, size));
+
+	HashMap<int32_t, FontGlyph> &gl = fd->cache[size]->glyph_map;
+
+	gl[p_glyph].rect.position = p_offset;
+	gl[p_glyph].found = true;
+}
+
+Vector2 TextServerFallback::font_get_glyph_size(RID p_font_rid, const Vector2i &p_size, int32_t p_glyph) const {
+	FontDataFallback *fd = font_owner.getornull(p_font_rid);
+	ERR_FAIL_COND_V(!fd, Vector2());
+
+	MutexLock lock(fd->mutex);
+	Vector2i size = _get_size_outline(fd, p_size);
+
+	ERR_FAIL_COND_V(!_ensure_cache_for_size(fd, size), Vector2());
+	if (!_ensure_glyph(fd, size, p_glyph)) {
+		return Vector2(); // Invalid or non graphicl glyph, do not display errors.
+	}
+
+	const HashMap<int32_t, FontGlyph> &gl = fd->cache[size]->glyph_map;
+
+	if (fd->msdf) {
+		return gl[p_glyph].rect.size * (real_t)p_size.x / (real_t)fd->msdf_source_size;
+	} else {
+		return gl[p_glyph].rect.size;
+	}
+}
+
+void TextServerFallback::font_set_glyph_size(RID p_font_rid, const Vector2i &p_size, int32_t p_glyph, const Vector2 &p_gl_size) {
+	FontDataFallback *fd = font_owner.getornull(p_font_rid);
+	ERR_FAIL_COND(!fd);
+
+	MutexLock lock(fd->mutex);
+	Vector2i size = _get_size_outline(fd, p_size);
+
+	ERR_FAIL_COND(!_ensure_cache_for_size(fd, size));
+
+	HashMap<int32_t, FontGlyph> &gl = fd->cache[size]->glyph_map;
+
+	gl[p_glyph].rect.size = p_gl_size;
+	gl[p_glyph].found = true;
+}
+
+Rect2 TextServerFallback::font_get_glyph_uv_rect(RID p_font_rid, const Vector2i &p_size, int32_t p_glyph) const {
+	FontDataFallback *fd = font_owner.getornull(p_font_rid);
+	ERR_FAIL_COND_V(!fd, Rect2());
+
+	MutexLock lock(fd->mutex);
+	Vector2i size = _get_size_outline(fd, p_size);
+
+	ERR_FAIL_COND_V(!_ensure_cache_for_size(fd, size), Rect2());
+	if (!_ensure_glyph(fd, size, p_glyph)) {
+		return Rect2(); // Invalid or non graphicl glyph, do not display errors.
+	}
+
+	const HashMap<int32_t, FontGlyph> &gl = fd->cache[size]->glyph_map;
+	return gl[p_glyph].uv_rect;
+}
+
+void TextServerFallback::font_set_glyph_uv_rect(RID p_font_rid, const Vector2i &p_size, int32_t p_glyph, const Rect2 &p_uv_rect) {
+	FontDataFallback *fd = font_owner.getornull(p_font_rid);
+	ERR_FAIL_COND(!fd);
+
+	MutexLock lock(fd->mutex);
+	Vector2i size = _get_size_outline(fd, p_size);
+
+	ERR_FAIL_COND(!_ensure_cache_for_size(fd, size));
+
+	HashMap<int32_t, FontGlyph> &gl = fd->cache[size]->glyph_map;
+
+	gl[p_glyph].uv_rect = p_uv_rect;
+	gl[p_glyph].found = true;
+}
+
+int TextServerFallback::font_get_glyph_texture_idx(RID p_font_rid, const Vector2i &p_size, int32_t p_glyph) const {
+	FontDataFallback *fd = font_owner.getornull(p_font_rid);
+	ERR_FAIL_COND_V(!fd, -1);
+
+	MutexLock lock(fd->mutex);
+	Vector2i size = _get_size_outline(fd, p_size);
+
+	ERR_FAIL_COND_V(!_ensure_cache_for_size(fd, size), -1);
+	if (!_ensure_glyph(fd, size, p_glyph)) {
+		return -1; // Invalid or non graphicl glyph, do not display errors.
+	}
+
+	const HashMap<int32_t, FontGlyph> &gl = fd->cache[size]->glyph_map;
+	return gl[p_glyph].texture_idx;
+}
+
+void TextServerFallback::font_set_glyph_texture_idx(RID p_font_rid, const Vector2i &p_size, int32_t p_glyph, int p_texture_idx) {
+	FontDataFallback *fd = font_owner.getornull(p_font_rid);
+	ERR_FAIL_COND(!fd);
+
+	MutexLock lock(fd->mutex);
+	Vector2i size = _get_size_outline(fd, p_size);
+
+	ERR_FAIL_COND(!_ensure_cache_for_size(fd, size));
+
+	HashMap<int32_t, FontGlyph> &gl = fd->cache[size]->glyph_map;
+
+	gl[p_glyph].texture_idx = p_texture_idx;
+	gl[p_glyph].found = true;
+}
+
+bool TextServerFallback::font_get_glyph_contours(RID p_font_rid, int p_size, int32_t p_index, Vector<Vector3> &r_points, Vector<int32_t> &r_contours, bool &r_orientation) const {
+	FontDataFallback *fd = font_owner.getornull(p_font_rid);
 	ERR_FAIL_COND_V(!fd, false);
-	return fd->get_force_autohinter();
+
+	MutexLock lock(fd->mutex);
+	Vector2i size = _get_size(fd, p_size);
+
+	ERR_FAIL_COND_V(!_ensure_cache_for_size(fd, size), false);
+
+#ifdef MODULE_FREETYPE_ENABLED
+	int error = FT_Load_Glyph(fd->cache[size]->face, p_index, FT_LOAD_NO_BITMAP | (fd->force_autohinter ? FT_LOAD_FORCE_AUTOHINT : 0));
+	ERR_FAIL_COND_V(error, false);
+
+	r_points.clear();
+	r_contours.clear();
+
+	real_t h = fd->cache[size]->ascent;
+	real_t scale = (1.0 / 64.0) / fd->cache[size]->oversampling * fd->cache[size]->scale;
+	if (fd->msdf) {
+		scale = scale * (real_t)p_size / (real_t)fd->msdf_source_size;
+	}
+	for (short i = 0; i < fd->cache[size]->face->glyph->outline.n_points; i++) {
+		r_points.push_back(Vector3(fd->cache[size]->face->glyph->outline.points[i].x * scale, h - fd->cache[size]->face->glyph->outline.points[i].y * scale, FT_CURVE_TAG(fd->cache[size]->face->glyph->outline.tags[i])));
+	}
+	for (short i = 0; i < fd->cache[size]->face->glyph->outline.n_contours; i++) {
+		r_contours.push_back(fd->cache[size]->face->glyph->outline.contours[i]);
+	}
+	r_orientation = (FT_Outline_Get_Orientation(&fd->cache[size]->face->glyph->outline) == FT_ORIENTATION_FILL_RIGHT);
+#else
+	return false;
+#endif
+	return true;
 }
 
-bool TextServerFallback::font_has_char(RID p_font, char32_t p_char) const {
-	_THREAD_SAFE_METHOD_
-	const FontDataFallback *fd = font_owner.getornull(p_font);
+Array TextServerFallback::font_get_kerning_list(RID p_font_rid, int p_size) const {
+	FontDataFallback *fd = font_owner.getornull(p_font_rid);
+	ERR_FAIL_COND_V(!fd, Array());
+
+	MutexLock lock(fd->mutex);
+	Vector2i size = _get_size(fd, p_size);
+
+	ERR_FAIL_COND_V(!_ensure_cache_for_size(fd, size), Array());
+
+	Array ret;
+	for (const Map<Vector2i, Vector2>::Element *E = fd->cache[size]->kerning_map.front(); E; E = E->next()) {
+		ret.push_back(E->key());
+	}
+	return ret;
+}
+
+void TextServerFallback::font_clear_kerning_map(RID p_font_rid, int p_size) {
+	FontDataFallback *fd = font_owner.getornull(p_font_rid);
+	ERR_FAIL_COND(!fd);
+
+	MutexLock lock(fd->mutex);
+	Vector2i size = _get_size(fd, p_size);
+
+	ERR_FAIL_COND(!_ensure_cache_for_size(fd, size));
+	fd->cache[size]->kerning_map.clear();
+}
+
+void TextServerFallback::font_remove_kerning(RID p_font_rid, int p_size, const Vector2i &p_glyph_pair) {
+	FontDataFallback *fd = font_owner.getornull(p_font_rid);
+	ERR_FAIL_COND(!fd);
+
+	MutexLock lock(fd->mutex);
+	Vector2i size = _get_size(fd, p_size);
+
+	ERR_FAIL_COND(!_ensure_cache_for_size(fd, size));
+	fd->cache[size]->kerning_map.erase(p_glyph_pair);
+}
+
+void TextServerFallback::font_set_kerning(RID p_font_rid, int p_size, const Vector2i &p_glyph_pair, const Vector2 &p_kerning) {
+	FontDataFallback *fd = font_owner.getornull(p_font_rid);
+	ERR_FAIL_COND(!fd);
+
+	MutexLock lock(fd->mutex);
+	Vector2i size = _get_size(fd, p_size);
+
+	ERR_FAIL_COND(!_ensure_cache_for_size(fd, size));
+	fd->cache[size]->kerning_map[p_glyph_pair] = p_kerning;
+}
+
+Vector2 TextServerFallback::font_get_kerning(RID p_font_rid, int p_size, const Vector2i &p_glyph_pair) const {
+	FontDataFallback *fd = font_owner.getornull(p_font_rid);
+	ERR_FAIL_COND_V(!fd, Vector2());
+
+	MutexLock lock(fd->mutex);
+	Vector2i size = _get_size(fd, p_size);
+
+	ERR_FAIL_COND_V(!_ensure_cache_for_size(fd, size), Vector2());
+
+	const Map<Vector2i, Vector2> &kern = fd->cache[size]->kerning_map;
+
+	if (kern.has(p_glyph_pair)) {
+		if (fd->msdf) {
+			return kern[p_glyph_pair] * (real_t)p_size / (real_t)fd->msdf_source_size;
+		} else {
+			return kern[p_glyph_pair];
+		}
+	} else {
+#ifdef MODULE_FREETYPE_ENABLED
+		if (fd->cache[size]->face) {
+			FT_Vector delta;
+			FT_Get_Kerning(fd->cache[size]->face, p_glyph_pair.x, p_glyph_pair.y, FT_KERNING_DEFAULT, &delta);
+			if (fd->msdf) {
+				return Vector2(delta.x, delta.y) * (real_t)p_size / (real_t)fd->msdf_source_size;
+			} else {
+				return Vector2(delta.x, delta.y);
+			}
+		}
+#endif
+	}
+	return Vector2();
+}
+
+int32_t TextServerFallback::font_get_glyph_index(RID p_font_rid, int p_size, char32_t p_char, char32_t p_variation_selector) const {
+	FontDataFallback *fd = font_owner.getornull(p_font_rid);
+	ERR_FAIL_COND_V(!fd, 0);
+
+	MutexLock lock(fd->mutex);
+	Vector2i size = _get_size(fd, p_size);
+	ERR_FAIL_COND_V(!_ensure_cache_for_size(fd, size), 0);
+
+#ifdef MODULE_FREETYPE_ENABLED
+	if (fd->cache[size]->face) {
+		if (p_variation_selector) {
+			return FT_Face_GetCharVariantIndex(fd->cache[size]->face, p_char, p_variation_selector);
+		} else {
+			return FT_Get_Char_Index(fd->cache[size]->face, p_char);
+		}
+	} else {
+		return 0;
+	}
+#else
+	return (int32_t)p_char;
+#endif
+}
+
+bool TextServerFallback::font_has_char(RID p_font_rid, char32_t p_char) const {
+	FontDataFallback *fd = font_owner.getornull(p_font_rid);
 	ERR_FAIL_COND_V(!fd, false);
-	return fd->has_char(p_char);
+
+	MutexLock lock(fd->mutex);
+	if (fd->cache.is_empty()) {
+		ERR_FAIL_COND_V(!_ensure_cache_for_size(fd, fd->msdf ? Vector2i(fd->msdf_source_size, 0) : Vector2i(16, 0)), false);
+	}
+	FontDataForSizeFallback *at_size = fd->cache.front()->get();
+
+#ifdef MODULE_FREETYPE_ENABLED
+	if (at_size && at_size->face) {
+		return FT_Get_Char_Index(at_size->face, p_char) != 0;
+	}
+#endif
+	return (at_size) ? at_size->glyph_map.has((int32_t)p_char) : false;
 }
 
-String TextServerFallback::font_get_supported_chars(RID p_font) const {
-	_THREAD_SAFE_METHOD_
-	const FontDataFallback *fd = font_owner.getornull(p_font);
+String TextServerFallback::font_get_supported_chars(RID p_font_rid) const {
+	FontDataFallback *fd = font_owner.getornull(p_font_rid);
 	ERR_FAIL_COND_V(!fd, String());
-	return fd->get_supported_chars();
+
+	MutexLock lock(fd->mutex);
+	if (fd->cache.is_empty()) {
+		ERR_FAIL_COND_V(!_ensure_cache_for_size(fd, fd->msdf ? Vector2i(fd->msdf_source_size, 0) : Vector2i(16, 0)), String());
+	}
+	FontDataForSizeFallback *at_size = fd->cache.front()->get();
+
+	String chars;
+#ifdef MODULE_FREETYPE_ENABLED
+	if (at_size && at_size->face) {
+		FT_UInt gindex;
+		FT_ULong charcode = FT_Get_First_Char(at_size->face, &gindex);
+		while (gindex != 0) {
+			if (charcode != 0) {
+				chars += char32_t(charcode);
+			}
+			charcode = FT_Get_Next_Char(at_size->face, charcode, &gindex);
+		}
+		return chars;
+	}
+#endif
+	if (at_size) {
+		const HashMap<int32_t, FontGlyph> &gl = at_size->glyph_map;
+		const int32_t *E = nullptr;
+		while ((E = gl.next(E))) {
+			chars += char32_t(*E);
+		}
+	}
+	return chars;
 }
 
-bool TextServerFallback::font_has_outline(RID p_font) const {
-	_THREAD_SAFE_METHOD_
-	const FontDataFallback *fd = font_owner.getornull(p_font);
-	ERR_FAIL_COND_V(!fd, false);
-	return fd->has_outline();
+void TextServerFallback::font_render_range(RID p_font_rid, const Vector2i &p_size, char32_t p_start, char32_t p_end) {
+	FontDataFallback *fd = font_owner.getornull(p_font_rid);
+	ERR_FAIL_COND(!fd);
+
+	MutexLock lock(fd->mutex);
+	Vector2i size = _get_size_outline(fd, p_size);
+	ERR_FAIL_COND(!_ensure_cache_for_size(fd, size));
+	for (char32_t i = p_start; i <= p_end; i++) {
+#ifdef MODULE_FREETYPE_ENABLED
+		if (fd->cache[size]->face) {
+			_ensure_glyph(fd, size, FT_Get_Char_Index(fd->cache[size]->face, i));
+			continue;
+		}
+#endif
+		_ensure_glyph(fd, size, (int32_t)i);
+	}
 }
 
-float TextServerFallback::font_get_base_size(RID p_font) const {
-	_THREAD_SAFE_METHOD_
-	const FontDataFallback *fd = font_owner.getornull(p_font);
-	ERR_FAIL_COND_V(!fd, 0.f);
-	return fd->get_base_size();
+void TextServerFallback::font_render_glyph(RID p_font_rid, const Vector2i &p_size, int32_t p_index) {
+	FontDataFallback *fd = font_owner.getornull(p_font_rid);
+	ERR_FAIL_COND(!fd);
+
+	MutexLock lock(fd->mutex);
+	Vector2i size = _get_size_outline(fd, p_size);
+	ERR_FAIL_COND(!_ensure_cache_for_size(fd, size));
+	ERR_FAIL_COND(!_ensure_glyph(fd, size, p_index));
 }
 
-bool TextServerFallback::font_is_language_supported(RID p_font, const String &p_language) const {
-	_THREAD_SAFE_METHOD_
-	const FontDataFallback *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]];
+void TextServerFallback::font_draw_glyph(RID p_font_rid, RID p_canvas, int p_size, const Vector2 &p_pos, int32_t p_index, const Color &p_color) const {
+	FontDataFallback *fd = font_owner.getornull(p_font_rid);
+	ERR_FAIL_COND(!fd);
+
+	MutexLock lock(fd->mutex);
+	Vector2i size = _get_size(fd, p_size);
+	ERR_FAIL_COND(!_ensure_cache_for_size(fd, size));
+	if (!_ensure_glyph(fd, size, p_index)) {
+		return; // // Invalid or non graphicl glyph, do not display errors, nothing to draw.
+	}
+
+	const FontGlyph &gl = fd->cache[size]->glyph_map[p_index];
+	if (gl.found) {
+		ERR_FAIL_COND(gl.texture_idx < -1 || gl.texture_idx >= fd->cache[size]->textures.size());
+
+		if (gl.texture_idx != -1) {
+			Color modulate = p_color;
+#ifdef MODULE_FREETYPE_ENABLED
+			if (fd->cache[size]->face && FT_HAS_COLOR(fd->cache[size]->face)) {
+				modulate.r = modulate.g = modulate.b = 1.0;
+			}
+#endif
+			if (RenderingServer::get_singleton() != nullptr) {
+				RID texture = fd->cache[size]->textures[gl.texture_idx].texture->get_rid();
+				if (fd->msdf) {
+					Point2 cpos = p_pos;
+					cpos += gl.rect.position * (real_t)p_size / (real_t)fd->msdf_source_size;
+					Size2 csize = gl.rect.size * (real_t)p_size / (real_t)fd->msdf_source_size;
+					RenderingServer::get_singleton()->canvas_item_add_msdf_texture_rect_region(p_canvas, Rect2(cpos, csize), texture, gl.uv_rect, modulate, 0, fd->msdf_range);
+				} else {
+					Point2i cpos = p_pos;
+					cpos += gl.rect.position;
+					Size2i csize = gl.rect.size;
+					RenderingServer::get_singleton()->canvas_item_add_texture_rect_region(p_canvas, Rect2(cpos, csize), texture, gl.uv_rect, modulate, false, false);
+				}
 			}
 		}
-		return false;
 	}
 }
 
-void TextServerFallback::font_set_language_support_override(RID p_font, const String &p_language, bool p_supported) {
-	_THREAD_SAFE_METHOD_
-	FontDataFallback *fd = font_owner.getornull(p_font);
+void TextServerFallback::font_draw_glyph_outline(RID p_font_rid, RID p_canvas, int p_size, int p_outline_size, const Vector2 &p_pos, int32_t p_index, const Color &p_color) const {
+	FontDataFallback *fd = font_owner.getornull(p_font_rid);
 	ERR_FAIL_COND(!fd);
-	fd->lang_support_overrides[p_language] = p_supported;
+
+	MutexLock lock(fd->mutex);
+	Vector2i size = _get_size_outline(fd, Vector2i(p_size, p_outline_size));
+	ERR_FAIL_COND(!_ensure_cache_for_size(fd, size));
+	if (!_ensure_glyph(fd, size, p_index)) {
+		return; // // Invalid or non graphicl glyph, do not display errors, nothing to draw.
+	}
+
+	const FontGlyph &gl = fd->cache[size]->glyph_map[p_index];
+	if (gl.found) {
+		ERR_FAIL_COND(gl.texture_idx < -1 || gl.texture_idx >= fd->cache[size]->textures.size());
+
+		if (gl.texture_idx != -1) {
+			Color modulate = p_color;
+#ifdef MODULE_FREETYPE_ENABLED
+			if (fd->cache[size]->face && FT_HAS_COLOR(fd->cache[size]->face)) {
+				modulate.r = modulate.g = modulate.b = 1.0;
+			}
+#endif
+			if (RenderingServer::get_singleton() != nullptr) {
+				RID texture = fd->cache[size]->textures[gl.texture_idx].texture->get_rid();
+				if (fd->msdf) {
+					Point2 cpos = p_pos;
+					cpos += gl.rect.position * (real_t)p_size / (real_t)fd->msdf_source_size;
+					Size2 csize = gl.rect.size * (real_t)p_size / (real_t)fd->msdf_source_size;
+					RenderingServer::get_singleton()->canvas_item_add_msdf_texture_rect_region(p_canvas, Rect2(cpos, csize), texture, gl.uv_rect, modulate, p_outline_size * 2, fd->msdf_range);
+				} else {
+					Point2i cpos = p_pos;
+					cpos += gl.rect.position;
+					Size2i csize = gl.rect.size;
+					RenderingServer::get_singleton()->canvas_item_add_texture_rect_region(p_canvas, Rect2(cpos, csize), texture, gl.uv_rect, modulate, false, false);
+				}
+			}
+		}
+	}
 }
 
-bool TextServerFallback::font_get_language_support_override(RID p_font, const String &p_language) {
-	_THREAD_SAFE_METHOD_
-	FontDataFallback *fd = font_owner.getornull(p_font);
+bool TextServerFallback::font_is_language_supported(RID p_font_rid, const String &p_language) const {
+	FontDataFallback *fd = font_owner.getornull(p_font_rid);
 	ERR_FAIL_COND_V(!fd, false);
-	return fd->lang_support_overrides[p_language];
+
+	MutexLock lock(fd->mutex);
+	if (fd->language_support_overrides.has(p_language)) {
+		return fd->language_support_overrides[p_language];
+	} else {
+		return true;
+	}
 }
 
-void TextServerFallback::font_remove_language_support_override(RID p_font, const String &p_language) {
-	_THREAD_SAFE_METHOD_
-	FontDataFallback *fd = font_owner.getornull(p_font);
+void TextServerFallback::font_set_language_support_override(RID p_font_rid, const String &p_language, bool p_supported) {
+	FontDataFallback *fd = font_owner.getornull(p_font_rid);
 	ERR_FAIL_COND(!fd);
-	fd->lang_support_overrides.erase(p_language);
+
+	MutexLock lock(fd->mutex);
+	fd->language_support_overrides[p_language] = p_supported;
 }
 
-Vector<String> TextServerFallback::font_get_language_support_overrides(RID p_font) {
-	_THREAD_SAFE_METHOD_
-	FontDataFallback *fd = font_owner.getornull(p_font);
+bool TextServerFallback::font_get_language_support_override(RID p_font_rid, const String &p_language) {
+	FontDataFallback *fd = font_owner.getornull(p_font_rid);
+	ERR_FAIL_COND_V(!fd, false);
+
+	MutexLock lock(fd->mutex);
+	return fd->language_support_overrides[p_language];
+}
+
+void TextServerFallback::font_remove_language_support_override(RID p_font_rid, const String &p_language) {
+	FontDataFallback *fd = font_owner.getornull(p_font_rid);
+	ERR_FAIL_COND(!fd);
+
+	MutexLock lock(fd->mutex);
+	fd->language_support_overrides.erase(p_language);
+}
+
+Vector<String> TextServerFallback::font_get_language_support_overrides(RID p_font_rid) {
+	FontDataFallback *fd = font_owner.getornull(p_font_rid);
 	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());
+
+	MutexLock lock(fd->mutex);
+	Vector<String> out;
+	for (const Map<String, bool>::Element *E = fd->language_support_overrides.front(); E; E = E->next()) {
+		out.push_back(E->key());
 	}
-	return ret;
+	return out;
 }
 
-bool TextServerFallback::font_is_script_supported(RID p_font, const String &p_script) const {
-	_THREAD_SAFE_METHOD_
-	const FontDataFallback *fd = font_owner.getornull(p_font);
+bool TextServerFallback::font_is_script_supported(RID p_font_rid, const String &p_script) const {
+	FontDataFallback *fd = font_owner.getornull(p_font_rid);
 	ERR_FAIL_COND_V(!fd, false);
+
+	MutexLock lock(fd->mutex);
 	if (fd->script_support_overrides.has(p_script)) {
 		return fd->script_support_overrides[p_script];
 	} else {
@@ -392,95 +1890,84 @@ bool TextServerFallback::font_is_script_supported(RID p_font, const String &p_sc
 	}
 }
 
-void TextServerFallback::font_set_script_support_override(RID p_font, const String &p_script, bool p_supported) {
-	_THREAD_SAFE_METHOD_
-	FontDataFallback *fd = font_owner.getornull(p_font);
+void TextServerFallback::font_set_script_support_override(RID p_font_rid, const String &p_script, bool p_supported) {
+	FontDataFallback *fd = font_owner.getornull(p_font_rid);
 	ERR_FAIL_COND(!fd);
+
+	MutexLock lock(fd->mutex);
 	fd->script_support_overrides[p_script] = p_supported;
 }
 
-bool TextServerFallback::font_get_script_support_override(RID p_font, const String &p_script) {
-	_THREAD_SAFE_METHOD_
-	FontDataFallback *fd = font_owner.getornull(p_font);
+bool TextServerFallback::font_get_script_support_override(RID p_font_rid, const String &p_script) {
+	FontDataFallback *fd = font_owner.getornull(p_font_rid);
 	ERR_FAIL_COND_V(!fd, false);
+
+	MutexLock lock(fd->mutex);
 	return fd->script_support_overrides[p_script];
 }
 
-void TextServerFallback::font_remove_script_support_override(RID p_font, const String &p_script) {
-	_THREAD_SAFE_METHOD_
-	FontDataFallback *fd = font_owner.getornull(p_font);
+void TextServerFallback::font_remove_script_support_override(RID p_font_rid, const String &p_script) {
+	FontDataFallback *fd = font_owner.getornull(p_font_rid);
 	ERR_FAIL_COND(!fd);
+
+	MutexLock lock(fd->mutex);
+	Vector2i size = _get_size(fd, 16);
+	ERR_FAIL_COND(!_ensure_cache_for_size(fd, size));
 	fd->script_support_overrides.erase(p_script);
 }
 
-Vector<String> TextServerFallback::font_get_script_support_overrides(RID p_font) {
-	_THREAD_SAFE_METHOD_
-	FontDataFallback *fd = font_owner.getornull(p_font);
+Vector<String> TextServerFallback::font_get_script_support_overrides(RID p_font_rid) {
+	FontDataFallback *fd = font_owner.getornull(p_font_rid);
 	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 TextServerFallback::font_get_glyph_index(RID p_font, char32_t p_char, char32_t p_variation_selector) const {
-	return (uint32_t)p_char;
-}
-
-Vector2 TextServerFallback::font_get_glyph_advance(RID p_font, uint32_t p_index, int p_size) const {
-	_THREAD_SAFE_METHOD_
-	const FontDataFallback *fd = font_owner.getornull(p_font);
-	ERR_FAIL_COND_V(!fd, Vector2());
-	return fd->get_advance(p_index, p_size);
+	MutexLock lock(fd->mutex);
+	Vector<String> out;
+	for (const Map<String, bool>::Element *E = fd->script_support_overrides.front(); E; E = E->next()) {
+		out.push_back(E->key());
+	}
+	return out;
 }
 
-Vector2 TextServerFallback::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 FontDataFallback *fd = font_owner.getornull(p_font);
-	ERR_FAIL_COND_V(!fd, Vector2());
-	return fd->get_kerning(p_index_a, p_index_b, p_size);
+Dictionary TextServerFallback::font_supported_feature_list(RID p_font_rid) const {
+	return Dictionary();
 }
 
-Vector2 TextServerFallback::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 FontDataFallback *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);
-}
+Dictionary TextServerFallback::font_supported_variation_list(RID p_font_rid) const {
+	FontDataFallback *fd = font_owner.getornull(p_font_rid);
+	ERR_FAIL_COND_V(!fd, Dictionary());
 
-Vector2 TextServerFallback::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 FontDataFallback *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);
+	MutexLock lock(fd->mutex);
+	Vector2i size = _get_size(fd, 16);
+	ERR_FAIL_COND_V(!_ensure_cache_for_size(fd, size), Dictionary());
+	return fd->supported_varaitions;
 }
 
-bool TextServerFallback::font_get_glyph_contours(RID p_font, int p_size, uint32_t p_index, Vector<Vector3> &r_points, Vector<int32_t> &r_contours, bool &r_orientation) const {
-	_THREAD_SAFE_METHOD_
-	const FontDataFallback *fd = font_owner.getornull(p_font);
-	ERR_FAIL_COND_V(!fd, false);
-	return fd->get_glyph_contours(p_size, p_index, r_points, r_contours, r_orientation);
-}
-
-float TextServerFallback::font_get_oversampling() const {
+real_t TextServerFallback::font_get_global_oversampling() const {
 	return oversampling;
 }
 
-void TextServerFallback::font_set_oversampling(float p_oversampling) {
+void TextServerFallback::font_set_global_oversampling(real_t p_oversampling) {
 	_THREAD_SAFE_METHOD_
 	if (oversampling != p_oversampling) {
 		oversampling = p_oversampling;
 		List<RID> fonts;
 		font_owner.get_owned_list(&fonts);
+		bool font_cleared = false;
 		for (const RID &E : fonts) {
-			font_owner.getornull(E)->clear_cache();
+			if (!font_is_multichannel_signed_distance_field(E) && font_get_oversampling(E) <= 0) {
+				font_clear_size_cache(E);
+				font_cleared = true;
+			}
 		}
-	}
-}
 
-Vector<String> TextServerFallback::get_system_fonts() const {
-	return Vector<String>();
+		if (font_cleared) {
+			List<RID> text_bufs;
+			shaped_owner.get_owned_list(&text_bufs);
+			for (const RID &E : text_bufs) {
+				invalidate(shaped_owner.getornull(E));
+			}
+		}
+	}
 }
 
 /*************************************************************************/
@@ -533,10 +2020,10 @@ RID TextServerFallback::create_shaped_text(TextServer::Direction p_direction, Te
 }
 
 void TextServerFallback::shaped_text_clear(RID p_shaped) {
-	_THREAD_SAFE_METHOD_
 	ShapedTextData *sd = shaped_owner.getornull(p_shaped);
 	ERR_FAIL_COND(!sd);
 
+	MutexLock lock(sd->mutex);
 	sd->parent = RID();
 	sd->start = 0;
 	sd->end = 0;
@@ -557,9 +2044,10 @@ TextServer::Direction TextServerFallback::shaped_text_get_direction(RID p_shaped
 }
 
 void TextServerFallback::shaped_text_set_orientation(RID p_shaped, TextServer::Orientation p_orientation) {
-	_THREAD_SAFE_METHOD_
 	ShapedTextData *sd = shaped_owner.getornull(p_shaped);
 	ERR_FAIL_COND(!sd);
+
+	MutexLock lock(sd->mutex);
 	if (sd->orientation != p_orientation) {
 		if (sd->parent != RID()) {
 			full_copy(sd);
@@ -574,15 +2062,17 @@ void TextServerFallback::shaped_text_set_bidi_override(RID p_shaped, const Vecto
 }
 
 TextServer::Orientation TextServerFallback::shaped_text_get_orientation(RID p_shaped) const {
-	_THREAD_SAFE_METHOD_
 	const ShapedTextData *sd = shaped_owner.getornull(p_shaped);
 	ERR_FAIL_COND_V(!sd, TextServer::ORIENTATION_HORIZONTAL);
+
+	MutexLock lock(sd->mutex);
 	return sd->orientation;
 }
 
 void TextServerFallback::shaped_text_set_preserve_invalid(RID p_shaped, bool p_enabled) {
-	_THREAD_SAFE_METHOD_
 	ShapedTextData *sd = shaped_owner.getornull(p_shaped);
+
+	MutexLock lock(sd->mutex);
 	ERR_FAIL_COND(!sd);
 	if (sd->preserve_invalid != p_enabled) {
 		if (sd->parent != RID()) {
@@ -594,16 +2084,18 @@ void TextServerFallback::shaped_text_set_preserve_invalid(RID p_shaped, bool p_e
 }
 
 bool TextServerFallback::shaped_text_get_preserve_invalid(RID p_shaped) const {
-	_THREAD_SAFE_METHOD_
 	const ShapedTextData *sd = shaped_owner.getornull(p_shaped);
 	ERR_FAIL_COND_V(!sd, false);
+
+	MutexLock lock(sd->mutex);
 	return sd->preserve_invalid;
 }
 
 void TextServerFallback::shaped_text_set_preserve_control(RID p_shaped, bool p_enabled) {
-	_THREAD_SAFE_METHOD_
 	ShapedTextData *sd = shaped_owner.getornull(p_shaped);
 	ERR_FAIL_COND(!sd);
+
+	MutexLock lock(sd->mutex);
 	if (sd->preserve_control != p_enabled) {
 		if (sd->parent != RID()) {
 			full_copy(sd);
@@ -614,18 +2106,24 @@ void TextServerFallback::shaped_text_set_preserve_control(RID p_shaped, bool p_e
 }
 
 bool TextServerFallback::shaped_text_get_preserve_control(RID p_shaped) const {
-	_THREAD_SAFE_METHOD_
 	const ShapedTextData *sd = shaped_owner.getornull(p_shaped);
 	ERR_FAIL_COND_V(!sd, false);
+
+	MutexLock lock(sd->mutex);
 	return sd->preserve_control;
 }
 
 bool TextServerFallback::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_
 	ShapedTextData *sd = shaped_owner.getornull(p_shaped);
 	ERR_FAIL_COND_V(!sd, false);
+
+	MutexLock lock(sd->mutex);
 	ERR_FAIL_COND_V(p_size <= 0, false);
 
+	for (int i = 0; i < p_fonts.size(); i++) {
+		ERR_FAIL_COND_V(!font_owner.getornull(p_fonts[i]), false);
+	}
+
 	if (p_text.is_empty()) {
 		return true;
 	}
@@ -637,6 +2135,7 @@ bool TextServerFallback::shaped_text_add_string(RID p_shaped, const String &p_te
 	ShapedTextData::Span span;
 	span.start = sd->text.length();
 	span.end = span.start + p_text.length();
+
 	// Pre-sort fonts, push fonts with the language support first.
 	Vector<RID> fonts_no_match;
 	int font_count = p_fonts.size();
@@ -662,9 +2161,10 @@ bool TextServerFallback::shaped_text_add_string(RID p_shaped, const String &p_te
 }
 
 bool TextServerFallback::shaped_text_add_object(RID p_shaped, Variant p_key, const Size2 &p_size, InlineAlign p_inline_align, int p_length) {
-	_THREAD_SAFE_METHOD_
 	ShapedTextData *sd = shaped_owner.getornull(p_shaped);
 	ERR_FAIL_COND_V(!sd, false);
+
+	MutexLock lock(sd->mutex);
 	ERR_FAIL_COND_V(p_key == Variant(), false);
 	ERR_FAIL_COND_V(sd->objects.has(p_key), false);
 
@@ -692,9 +2192,10 @@ bool TextServerFallback::shaped_text_add_object(RID p_shaped, Variant p_key, con
 }
 
 bool TextServerFallback::shaped_text_resize_object(RID p_shaped, Variant p_key, const Size2 &p_size, InlineAlign p_inline_align) {
-	_THREAD_SAFE_METHOD_
 	ShapedTextData *sd = shaped_owner.getornull(p_shaped);
 	ERR_FAIL_COND_V(!sd, false);
+
+	MutexLock lock(sd->mutex);
 	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;
@@ -706,8 +2207,6 @@ bool TextServerFallback::shaped_text_resize_object(RID p_shaped, Variant p_key,
 		sd->upos = 0;
 		sd->uthk = 0;
 		int sd_size = sd->glyphs.size();
-		const FontDataFallback *fd = nullptr;
-		RID prev_rid = RID();
 
 		for (int i = 0; i < sd_size; i++) {
 			Glyph gl = sd->glyphs[i];
@@ -731,17 +2230,13 @@ bool TextServerFallback::shaped_text_resize_object(RID p_shaped, Variant p_key,
 					sd->glyphs.write[i].advance = sd->objects[key].rect.size.y;
 				}
 			} else {
-				if (prev_rid != gl.font_rid) {
-					fd = font_owner.getornull(gl.font_rid);
-					prev_rid = gl.font_rid;
-				}
-				if (fd != nullptr) {
+				if (gl.font_rid.is_valid()) {
 					if (sd->orientation == ORIENTATION_HORIZONTAL) {
-						sd->ascent = MAX(sd->ascent, fd->get_ascent(gl.font_size));
-						sd->descent = MAX(sd->descent, fd->get_descent(gl.font_size));
+						sd->ascent = MAX(sd->ascent, font_get_ascent(gl.font_rid, gl.font_size));
+						sd->descent = MAX(sd->descent, font_get_descent(gl.font_rid, gl.font_size));
 					} else {
-						sd->ascent = MAX(sd->ascent, Math::round(fd->get_advance(gl.index, gl.font_size).x * 0.5));
-						sd->descent = MAX(sd->descent, Math::round(fd->get_advance(gl.index, gl.font_size).x * 0.5));
+						sd->ascent = MAX(sd->ascent, Math::round(font_get_glyph_advance(gl.font_rid, gl.font_size, gl.index).x * 0.5));
+						sd->descent = MAX(sd->descent, Math::round(font_get_glyph_advance(gl.font_rid, gl.font_size, gl.index).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));
@@ -760,8 +2255,8 @@ bool TextServerFallback::shaped_text_resize_object(RID p_shaped, Variant p_key,
 		}
 
 		// Align embedded objects to baseline.
-		float full_ascent = sd->ascent;
-		float full_descent = sd->descent;
+		real_t full_ascent = sd->ascent;
+		real_t full_descent = sd->descent;
 		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) {
@@ -830,9 +2325,10 @@ bool TextServerFallback::shaped_text_resize_object(RID p_shaped, Variant p_key,
 }
 
 RID TextServerFallback::shaped_text_substr(RID p_shaped, int p_start, int p_length) const {
-	_THREAD_SAFE_METHOD_
 	const ShapedTextData *sd = shaped_owner.getornull(p_shaped);
 	ERR_FAIL_COND_V(!sd, RID());
+
+	MutexLock lock(sd->mutex);
 	if (sd->parent != RID()) {
 		return shaped_text_substr(sd->parent, p_start, p_length);
 	}
@@ -886,14 +2382,13 @@ RID TextServerFallback::shaped_text_substr(RID p_shaped, int p_start, int p_leng
 						new_sd->width += new_sd->objects[key].rect.size.y;
 					}
 				} else {
-					const FontDataFallback *fd = font_owner.getornull(gl.font_rid);
-					if (fd != nullptr) {
+					if (gl.font_rid.is_valid()) {
 						if (new_sd->orientation == ORIENTATION_HORIZONTAL) {
-							new_sd->ascent = MAX(new_sd->ascent, fd->get_ascent(gl.font_size));
-							new_sd->descent = MAX(new_sd->descent, fd->get_descent(gl.font_size));
+							new_sd->ascent = MAX(new_sd->ascent, font_get_ascent(gl.font_rid, gl.font_size));
+							new_sd->descent = MAX(new_sd->descent, font_get_descent(gl.font_rid, gl.font_size));
 						} else {
-							new_sd->ascent = MAX(new_sd->ascent, Math::round(fd->get_advance(gl.index, gl.font_size).x * 0.5));
-							new_sd->descent = MAX(new_sd->descent, Math::round(fd->get_advance(gl.index, gl.font_size).x * 0.5));
+							new_sd->ascent = MAX(new_sd->ascent, Math::round(font_get_glyph_advance(gl.font_rid, gl.font_size, gl.index).x * 0.5));
+							new_sd->descent = MAX(new_sd->descent, Math::round(font_get_glyph_advance(gl.font_rid, gl.font_size, gl.index).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.
@@ -912,8 +2407,8 @@ RID TextServerFallback::shaped_text_substr(RID p_shaped, int p_start, int p_leng
 		}
 
 		// Align embedded objects to baseline.
-		float full_ascent = new_sd->ascent;
-		float full_descent = new_sd->descent;
+		real_t full_ascent = new_sd->ascent;
+		real_t full_descent = new_sd->descent;
 		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) {
@@ -984,16 +2479,18 @@ RID TextServerFallback::shaped_text_substr(RID p_shaped, int p_start, int p_leng
 }
 
 RID TextServerFallback::shaped_text_get_parent(RID p_shaped) const {
-	_THREAD_SAFE_METHOD_
 	ShapedTextData *sd = shaped_owner.getornull(p_shaped);
 	ERR_FAIL_COND_V(!sd, RID());
+
+	MutexLock lock(sd->mutex);
 	return sd->parent;
 }
 
-float TextServerFallback::shaped_text_fit_to_width(RID p_shaped, float p_width, uint8_t /*JustificationFlag*/ p_jst_flags) {
-	_THREAD_SAFE_METHOD_
+real_t TextServerFallback::shaped_text_fit_to_width(RID p_shaped, real_t p_width, uint8_t /*JustificationFlag*/ p_jst_flags) {
 	ShapedTextData *sd = shaped_owner.getornull(p_shaped);
 	ERR_FAIL_COND_V(!sd, 0.f);
+
+	MutexLock lock(sd->mutex);
 	if (!sd->valid) {
 		const_cast<TextServerFallback *>(this)->shaped_text_shape(p_shaped);
 	}
@@ -1053,13 +2550,13 @@ float TextServerFallback::shaped_text_fit_to_width(RID p_shaped, float p_width,
 	}
 
 	if ((space_count > 0) && ((p_jst_flags & JUSTIFICATION_WORD_BOUND) == JUSTIFICATION_WORD_BOUND)) {
-		float delta_width_per_space = (p_width - sd->width) / space_count;
+		real_t 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;
-					gl.advance = Math::round(MAX(gl.advance + delta_width_per_space, 0.05 * gl.font_size));
+					real_t old_adv = gl.advance;
+					gl.advance = MAX(gl.advance + delta_width_per_space, Math::round(0.1 * gl.font_size));
 					sd->width += (gl.advance - old_adv);
 				}
 			}
@@ -1069,10 +2566,11 @@ float TextServerFallback::shaped_text_fit_to_width(RID p_shaped, float p_width,
 	return sd->width;
 }
 
-float TextServerFallback::shaped_text_tab_align(RID p_shaped, const Vector<float> &p_tab_stops) {
-	_THREAD_SAFE_METHOD_
+real_t TextServerFallback::shaped_text_tab_align(RID p_shaped, const Vector<real_t> &p_tab_stops) {
 	ShapedTextData *sd = shaped_owner.getornull(p_shaped);
 	ERR_FAIL_COND_V(!sd, 0.f);
+
+	MutexLock lock(sd->mutex);
 	if (!sd->valid) {
 		const_cast<TextServerFallback *>(this)->shaped_text_shape(p_shaped);
 	}
@@ -1081,7 +2579,7 @@ float TextServerFallback::shaped_text_tab_align(RID p_shaped, const Vector<float
 	}
 
 	int tab_index = 0;
-	float off = 0.f;
+	real_t off = 0.f;
 
 	int start, end, delta;
 	if (sd->para_direction == DIRECTION_LTR) {
@@ -1098,7 +2596,7 @@ float TextServerFallback::shaped_text_tab_align(RID p_shaped, const Vector<float
 
 	for (int i = start; i != end; i += delta) {
 		if ((gl[i].flags & GRAPHEME_IS_TAB) == GRAPHEME_IS_TAB) {
-			float tab_off = 0.f;
+			real_t tab_off = 0.f;
 			while (tab_off <= off) {
 				tab_off += p_tab_stops[tab_index];
 				tab_index++;
@@ -1106,7 +2604,7 @@ float TextServerFallback::shaped_text_tab_align(RID p_shaped, const Vector<float
 					tab_index = 0;
 				}
 			}
-			float old_adv = gl[i].advance;
+			real_t old_adv = gl[i].advance;
 			gl[i].advance = tab_off - off;
 			sd->width += gl[i].advance - old_adv;
 			off = 0;
@@ -1119,9 +2617,10 @@ float TextServerFallback::shaped_text_tab_align(RID p_shaped, const Vector<float
 }
 
 bool TextServerFallback::shaped_text_update_breaks(RID p_shaped) {
-	_THREAD_SAFE_METHOD_
 	ShapedTextData *sd = shaped_owner.getornull(p_shaped);
 	ERR_FAIL_COND_V(!sd, false);
+
+	MutexLock lock(sd->mutex);
 	if (!sd->valid) {
 		shaped_text_shape(p_shaped);
 	}
@@ -1159,9 +2658,10 @@ bool TextServerFallback::shaped_text_update_breaks(RID p_shaped) {
 }
 
 bool TextServerFallback::shaped_text_update_justification_ops(RID p_shaped) {
-	_THREAD_SAFE_METHOD_
 	ShapedTextData *sd = shaped_owner.getornull(p_shaped);
 	ERR_FAIL_COND_V(!sd, false);
+
+	MutexLock lock(sd->mutex);
 	if (!sd->valid) {
 		shaped_text_shape(p_shaped);
 	}
@@ -1173,10 +2673,11 @@ bool TextServerFallback::shaped_text_update_justification_ops(RID p_shaped) {
 	return true;
 }
 
-void TextServerFallback::shaped_text_overrun_trim_to_width(RID p_shaped_line, float p_width, uint8_t p_trim_flags) {
-	_THREAD_SAFE_METHOD_
+void TextServerFallback::shaped_text_overrun_trim_to_width(RID p_shaped_line, real_t p_width, uint8_t p_trim_flags) {
 	ShapedTextData *sd = shaped_owner.getornull(p_shaped_line);
-	ERR_FAIL_COND_MSG(!sd, "ShapedTextDataAdvanced invalid.");
+	ERR_FAIL_COND_MSG(!sd, "ShapedTextDataFallback invalid.");
+
+	MutexLock lock(sd->mutex);
 	if (!sd->valid) {
 		shaped_text_shape(p_shaped_line);
 	}
@@ -1203,18 +2704,18 @@ void TextServerFallback::shaped_text_overrun_trim_to_width(RID p_shaped_line, fl
 	int sd_size = sd->glyphs.size();
 	RID last_gl_font_rid = sd_glyphs[sd_size - 1].font_rid;
 	int last_gl_font_size = sd_glyphs[sd_size - 1].font_size;
-	uint32_t dot_gl_idx = font_get_glyph_index(last_gl_font_rid, '.');
-	Vector2 dot_adv = font_get_glyph_advance(last_gl_font_rid, dot_gl_idx, last_gl_font_size);
-	uint32_t whitespace_gl_idx = font_get_glyph_index(last_gl_font_rid, ' ');
-	Vector2 whitespace_adv = font_get_glyph_advance(last_gl_font_rid, whitespace_gl_idx, last_gl_font_size);
+	int32_t dot_gl_idx = font_get_glyph_index(last_gl_font_rid, '.', 0);
+	Vector2 dot_adv = font_get_glyph_advance(last_gl_font_rid, last_gl_font_size, dot_gl_idx);
+	int32_t whitespace_gl_idx = font_get_glyph_index(last_gl_font_rid, ' ', 0);
+	Vector2 whitespace_adv = font_get_glyph_advance(last_gl_font_rid, last_gl_font_size, whitespace_gl_idx);
 
 	int ellipsis_width = 0;
 	if (add_ellipsis) {
-		ellipsis_width = 3 * dot_adv.x + font_get_spacing_glyph(last_gl_font_rid) + (cut_per_word ? whitespace_adv.x : 0);
+		ellipsis_width = 3 * dot_adv.x + font_get_spacing(last_gl_font_rid, last_gl_font_size, TextServer::SPACING_GLYPH) + (cut_per_word ? whitespace_adv.x : 0);
 	}
 
 	int ell_min_characters = 6;
-	float width = sd->width;
+	real_t width = sd->width;
 
 	int trim_pos = 0;
 	int ellipsis_pos = (enforce_ellipsis) ? 0 : -1;
@@ -1289,16 +2790,18 @@ void TextServerFallback::shaped_text_overrun_trim_to_width(RID p_shaped_line, fl
 }
 
 TextServer::TrimData TextServerFallback::shaped_text_get_trim_data(RID p_shaped) const {
-	_THREAD_SAFE_METHOD_
 	ShapedTextData *sd = shaped_owner.getornull(p_shaped);
-	ERR_FAIL_COND_V_MSG(!sd, TrimData(), "ShapedTextDataAdvanced invalid.");
+	ERR_FAIL_COND_V_MSG(!sd, TrimData(), "ShapedTextDataFallback invalid.");
+
+	MutexLock lock(sd->mutex);
 	return sd->overrun_trim_data;
 }
 
 bool TextServerFallback::shaped_text_shape(RID p_shaped) {
-	_THREAD_SAFE_METHOD_
 	ShapedTextData *sd = shaped_owner.getornull(p_shaped);
 	ERR_FAIL_COND_V(!sd, false);
+
+	MutexLock lock(sd->mutex);
 	if (sd->valid) {
 		return true;
 	}
@@ -1347,14 +2850,12 @@ bool TextServerFallback::shaped_text_shape(RID p_shaped) {
 		} else {
 			// Text span.
 			for (int j = span.start; j < span.end; j++) {
-				const FontDataFallback *fd = nullptr;
-
 				Glyph gl;
 				gl.start = j;
 				gl.end = j + 1;
 				gl.count = 1;
 				gl.font_size = span.font_size;
-				gl.index = (uint32_t)sd->text[j]; // Use codepoint.
+				gl.index = (int32_t)sd->text[j]; // Use codepoint.
 				if (gl.index == 0x0009 || gl.index == 0x000b) {
 					gl.index = 0x0020;
 				}
@@ -1363,45 +2864,44 @@ bool TextServerFallback::shaped_text_shape(RID p_shaped) {
 				}
 				// Select first font which has character (font are already sorted by span language).
 				for (int k = 0; k < span.fonts.size(); k++) {
-					fd = font_owner.getornull(span.fonts[k]);
-					if (fd != nullptr && fd->has_char(gl.index)) {
+					if (font_has_char(span.fonts[k], gl.index)) {
 						gl.font_rid = span.fonts[k];
 						break;
 					}
 				}
 
-				if (gl.font_rid != RID()) {
+				if (gl.font_rid.is_valid()) {
 					if (sd->text[j] != 0 && !is_linebreak(sd->text[j])) {
 						if (sd->orientation == ORIENTATION_HORIZONTAL) {
-							gl.advance = fd->get_advance(gl.index, gl.font_size).x;
+							gl.advance = font_get_glyph_advance(gl.font_rid, gl.font_size, gl.index).x;
 							gl.x_off = 0;
 							gl.y_off = 0;
-							sd->ascent = MAX(sd->ascent, fd->get_ascent(gl.font_size));
-							sd->descent = MAX(sd->descent, fd->get_descent(gl.font_size));
+							sd->ascent = MAX(sd->ascent, font_get_ascent(gl.font_rid, gl.font_size));
+							sd->descent = MAX(sd->descent, font_get_descent(gl.font_rid, gl.font_size));
 						} else {
-							gl.advance = fd->get_advance(gl.index, gl.font_size).y;
-							gl.x_off = -Math::round(fd->get_advance(gl.index, gl.font_size).x * 0.5);
-							gl.y_off = fd->get_ascent(gl.font_size);
-							sd->ascent = MAX(sd->ascent, Math::round(fd->get_advance(gl.index, gl.font_size).x * 0.5));
-							sd->descent = MAX(sd->descent, Math::round(fd->get_advance(gl.index, gl.font_size).x * 0.5));
+							gl.advance = font_get_glyph_advance(gl.font_rid, gl.font_size, gl.index).y;
+							gl.x_off = -Math::round(font_get_glyph_advance(gl.font_rid, gl.font_size, gl.index).x * 0.5);
+							gl.y_off = font_get_ascent(gl.font_rid, gl.font_size);
+							sd->ascent = MAX(sd->ascent, Math::round(font_get_glyph_advance(gl.font_rid, gl.font_size, gl.index).x * 0.5));
+							sd->descent = MAX(sd->descent, Math::round(font_get_glyph_advance(gl.font_rid, gl.font_size, gl.index).x * 0.5));
 						}
 					}
-					if (fd->get_spacing_space() && is_whitespace(sd->text[j])) {
-						gl.advance += fd->get_spacing_space();
+					if (font_get_spacing(gl.font_rid, gl.font_size, TextServer::SPACING_SPACE) && is_whitespace(sd->text[j])) {
+						gl.advance += font_get_spacing(gl.font_rid, gl.font_size, TextServer::SPACING_SPACE);
 					} else {
-						gl.advance += fd->get_spacing_glyph();
+						gl.advance += font_get_spacing(gl.font_rid, gl.font_size, TextServer::SPACING_GLYPH);
 					}
-					sd->upos = MAX(sd->upos, fd->get_underline_position(gl.font_size));
-					sd->uthk = MAX(sd->uthk, fd->get_underline_thickness(gl.font_size));
+					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));
 
 					// Add kerning to previous glyph.
 					if (sd->glyphs.size() > 0) {
 						Glyph &prev_gl = sd->glyphs.write[sd->glyphs.size() - 1];
 						if (prev_gl.font_rid == gl.font_rid && prev_gl.font_size == gl.font_size) {
 							if (sd->orientation == ORIENTATION_HORIZONTAL) {
-								prev_gl.advance += fd->get_kerning(prev_gl.index, gl.index, gl.font_size).x;
+								prev_gl.advance += font_get_kerning(gl.font_rid, gl.font_size, Vector2i(prev_gl.index, gl.index)).x;
 							} else {
-								prev_gl.advance += fd->get_kerning(prev_gl.index, gl.index, gl.font_size).y;
+								prev_gl.advance += font_get_kerning(gl.font_rid, gl.font_size, Vector2i(prev_gl.index, gl.index)).y;
 							}
 						}
 					}
@@ -1424,8 +2924,8 @@ bool TextServerFallback::shaped_text_shape(RID p_shaped) {
 	}
 
 	// Align embedded objects to baseline.
-	float full_ascent = sd->ascent;
-	float full_descent = sd->descent;
+	real_t full_ascent = sd->ascent;
+	real_t full_descent = sd->descent;
 	for (Map<Variant, ShapedTextData::EmbeddedObject>::Element *E = sd->objects.front(); E; E = E->next()) {
 		if (sd->orientation == ORIENTATION_HORIZONTAL) {
 			switch (E->get().inline_align & INLINE_ALIGN_TEXT_MASK) {
@@ -1492,16 +2992,18 @@ bool TextServerFallback::shaped_text_shape(RID p_shaped) {
 }
 
 bool TextServerFallback::shaped_text_is_ready(RID p_shaped) const {
-	_THREAD_SAFE_METHOD_
 	const ShapedTextData *sd = shaped_owner.getornull(p_shaped);
 	ERR_FAIL_COND_V(!sd, false);
+
+	MutexLock lock(sd->mutex);
 	return sd->valid;
 }
 
 Vector<TextServer::Glyph> TextServerFallback::shaped_text_get_glyphs(RID p_shaped) const {
-	_THREAD_SAFE_METHOD_
 	const ShapedTextData *sd = shaped_owner.getornull(p_shaped);
 	ERR_FAIL_COND_V(!sd, Vector<TextServer::Glyph>());
+
+	MutexLock lock(sd->mutex);
 	if (!sd->valid) {
 		const_cast<TextServerFallback *>(this)->shaped_text_shape(p_shaped);
 	}
@@ -1509,16 +3011,18 @@ Vector<TextServer::Glyph> TextServerFallback::shaped_text_get_glyphs(RID p_shape
 }
 
 Vector2i TextServerFallback::shaped_text_get_range(RID p_shaped) const {
-	_THREAD_SAFE_METHOD_
 	const ShapedTextData *sd = shaped_owner.getornull(p_shaped);
 	ERR_FAIL_COND_V(!sd, Vector2i());
+
+	MutexLock lock(sd->mutex);
 	return Vector2(sd->start, sd->end);
 }
 
 Vector<TextServer::Glyph> TextServerFallback::shaped_text_sort_logical(RID p_shaped) {
-	_THREAD_SAFE_METHOD_
 	const ShapedTextData *sd = shaped_owner.getornull(p_shaped);
 	ERR_FAIL_COND_V(!sd, Vector<TextServer::Glyph>());
+
+	MutexLock lock(sd->mutex);
 	if (!sd->valid) {
 		const_cast<TextServerFallback *>(this)->shaped_text_shape(p_shaped);
 	}
@@ -1527,10 +3031,11 @@ Vector<TextServer::Glyph> TextServerFallback::shaped_text_sort_logical(RID p_sha
 }
 
 Array TextServerFallback::shaped_text_get_objects(RID p_shaped) const {
-	_THREAD_SAFE_METHOD_
 	Array ret;
 	const ShapedTextData *sd = shaped_owner.getornull(p_shaped);
 	ERR_FAIL_COND_V(!sd, ret);
+
+	MutexLock lock(sd->mutex);
 	for (const Map<Variant, ShapedTextData::EmbeddedObject>::Element *E = sd->objects.front(); E; E = E->next()) {
 		ret.push_back(E->key());
 	}
@@ -1539,9 +3044,10 @@ Array TextServerFallback::shaped_text_get_objects(RID p_shaped) const {
 }
 
 Rect2 TextServerFallback::shaped_text_get_object_rect(RID p_shaped, Variant p_key) const {
-	_THREAD_SAFE_METHOD_
 	const ShapedTextData *sd = shaped_owner.getornull(p_shaped);
 	ERR_FAIL_COND_V(!sd, Rect2());
+
+	MutexLock lock(sd->mutex);
 	ERR_FAIL_COND_V(!sd->objects.has(p_key), Rect2());
 	if (!sd->valid) {
 		const_cast<TextServerFallback *>(this)->shaped_text_shape(p_shaped);
@@ -1550,9 +3056,10 @@ Rect2 TextServerFallback::shaped_text_get_object_rect(RID p_shaped, Variant p_ke
 }
 
 Size2 TextServerFallback::shaped_text_get_size(RID p_shaped) const {
-	_THREAD_SAFE_METHOD_
 	const ShapedTextData *sd = shaped_owner.getornull(p_shaped);
 	ERR_FAIL_COND_V(!sd, Size2());
+
+	MutexLock lock(sd->mutex);
 	if (!sd->valid) {
 		const_cast<TextServerFallback *>(this)->shaped_text_shape(p_shaped);
 	}
@@ -1563,40 +3070,44 @@ Size2 TextServerFallback::shaped_text_get_size(RID p_shaped) const {
 	}
 }
 
-float TextServerFallback::shaped_text_get_ascent(RID p_shaped) const {
-	_THREAD_SAFE_METHOD_
+real_t TextServerFallback::shaped_text_get_ascent(RID p_shaped) const {
 	const ShapedTextData *sd = shaped_owner.getornull(p_shaped);
 	ERR_FAIL_COND_V(!sd, 0.f);
+
+	MutexLock lock(sd->mutex);
 	if (!sd->valid) {
 		const_cast<TextServerFallback *>(this)->shaped_text_shape(p_shaped);
 	}
 	return sd->ascent;
 }
 
-float TextServerFallback::shaped_text_get_descent(RID p_shaped) const {
-	_THREAD_SAFE_METHOD_
+real_t TextServerFallback::shaped_text_get_descent(RID p_shaped) const {
 	const ShapedTextData *sd = shaped_owner.getornull(p_shaped);
 	ERR_FAIL_COND_V(!sd, 0.f);
+
+	MutexLock lock(sd->mutex);
 	if (!sd->valid) {
 		const_cast<TextServerFallback *>(this)->shaped_text_shape(p_shaped);
 	}
 	return sd->descent;
 }
 
-float TextServerFallback::shaped_text_get_width(RID p_shaped) const {
-	_THREAD_SAFE_METHOD_
+real_t TextServerFallback::shaped_text_get_width(RID p_shaped) const {
 	const ShapedTextData *sd = shaped_owner.getornull(p_shaped);
 	ERR_FAIL_COND_V(!sd, 0.f);
+
+	MutexLock lock(sd->mutex);
 	if (!sd->valid) {
 		const_cast<TextServerFallback *>(this)->shaped_text_shape(p_shaped);
 	}
 	return sd->width;
 }
 
-float TextServerFallback::shaped_text_get_underline_position(RID p_shaped) const {
-	_THREAD_SAFE_METHOD_
+real_t TextServerFallback::shaped_text_get_underline_position(RID p_shaped) const {
 	const ShapedTextData *sd = shaped_owner.getornull(p_shaped);
 	ERR_FAIL_COND_V(!sd, 0.f);
+
+	MutexLock lock(sd->mutex);
 	if (!sd->valid) {
 		const_cast<TextServerFallback *>(this)->shaped_text_shape(p_shaped);
 	}
@@ -1604,10 +3115,11 @@ float TextServerFallback::shaped_text_get_underline_position(RID p_shaped) const
 	return sd->upos;
 }
 
-float TextServerFallback::shaped_text_get_underline_thickness(RID p_shaped) const {
-	_THREAD_SAFE_METHOD_
+real_t TextServerFallback::shaped_text_get_underline_thickness(RID p_shaped) const {
 	const ShapedTextData *sd = shaped_owner.getornull(p_shaped);
 	ERR_FAIL_COND_V(!sd, 0.f);
+
+	MutexLock lock(sd->mutex);
 	if (!sd->valid) {
 		const_cast<TextServerFallback *>(this)->shaped_text_shape(p_shaped);
 	}
@@ -1623,3 +3135,11 @@ TextServer *TextServerFallback::create_func(Error &r_error, void *p_user_data) {
 void TextServerFallback::register_server() {
 	TextServerManager::register_create_function(interface_name, interface_features, create_func, nullptr);
 }
+
+TextServerFallback::TextServerFallback(){};
+
+TextServerFallback::~TextServerFallback() {
+	if (library != nullptr) {
+		FT_Done_FreeType(library);
+	}
+};
diff --git a/modules/text_server_fb/text_server_fb.h b/modules/text_server_fb/text_server_fb.h
index d4cab2409a..fde75e7135 100644
--- a/modules/text_server_fb/text_server_fb.h
+++ b/modules/text_server_fb/text_server_fb.h
@@ -39,22 +39,165 @@
 #include "servers/text_server.h"
 
 #include "core/templates/rid_owner.h"
-
+#include "core/templates/thread_work_pool.h"
 #include "scene/resources/texture.h"
 
-#include "font_fb.h"
+#include "modules/modules_enabled.gen.h"
+
+#ifdef MODULE_FREETYPE_ENABLED
+#include <ft2build.h>
+#include FT_FREETYPE_H
+#include FT_TRUETYPE_TABLES_H
+#include FT_STROKER_H
+#include FT_ADVANCES_H
+#include FT_MULTIPLE_MASTERS_H
+#include FT_BBOX_H
+#endif
 
 class TextServerFallback : public TextServer {
 	GDCLASS(TextServerFallback, TextServer);
 	_THREAD_SAFE_CLASS_
 
-	float oversampling = 1.f;
-	mutable RID_PtrOwner<FontDataFallback> font_owner;
-	mutable RID_PtrOwner<ShapedTextData> shaped_owner;
-
 	static String interface_name;
 	static uint32_t interface_features;
 
+	// Font cache data.
+
+#ifdef MODULE_FREETYPE_ENABLED
+	mutable FT_Library library = nullptr;
+#endif
+
+	const int rect_range = 2;
+
+	struct FontTexture {
+		Image::Format format;
+		PackedByteArray imgdata;
+		int texture_w = 0;
+		int texture_h = 0;
+		PackedInt32Array offsets;
+		Ref<ImageTexture> texture;
+	};
+
+	struct FontTexturePosition {
+		int index = 0;
+		int x = 0;
+		int y = 0;
+	};
+
+	struct FontGlyph {
+		bool found = false;
+		int texture_idx = -1;
+		Rect2 rect;
+		Rect2 uv_rect;
+		Vector2 advance;
+	};
+
+	struct FontDataForSizeFallback {
+		real_t ascent = 0.f;
+		real_t descent = 0.f;
+		real_t underline_position = 0.f;
+		real_t underline_thickness = 0.f;
+		real_t scale = 1.f;
+		real_t oversampling = 1.f;
+
+		int spacing_glyph = 0;
+		int spacing_space = 0;
+
+		Vector2i size;
+
+		Vector<FontTexture> textures;
+		HashMap<int32_t, FontGlyph> glyph_map;
+		Map<Vector2i, Vector2> kerning_map;
+
+#ifdef MODULE_FREETYPE_ENABLED
+		FT_Face face = nullptr;
+		FT_StreamRec stream;
+#endif
+
+		~FontDataForSizeFallback() {
+#ifdef MODULE_FREETYPE_ENABLED
+			if (face != nullptr) {
+				FT_Done_Face(face);
+			}
+#endif
+		}
+	};
+
+	struct FontDataFallback {
+		Mutex mutex;
+
+		bool antialiased = true;
+		bool msdf = false;
+		int msdf_range = 14;
+		int msdf_source_size = 48;
+		int fixed_size = 0;
+		bool force_autohinter = false;
+		TextServer::Hinting hinting = TextServer::HINTING_LIGHT;
+		Dictionary variation_coordinates;
+		real_t oversampling = 0.f;
+
+		Map<Vector2i, FontDataForSizeFallback *> cache;
+
+		bool face_init = false;
+		Dictionary supported_varaitions;
+
+		// Language/script support override.
+		Map<String, bool> language_support_overrides;
+		Map<String, bool> script_support_overrides;
+
+		PackedByteArray data;
+		const uint8_t *data_ptr;
+		size_t data_size;
+
+		mutable ThreadWorkPool work_pool;
+
+		~FontDataFallback() {
+			work_pool.finish();
+			for (const Map<Vector2i, FontDataForSizeFallback *>::Element *E = cache.front(); E; E = E->next()) {
+				memdelete(E->get());
+			}
+			cache.clear();
+		}
+	};
+
+	_FORCE_INLINE_ FontTexturePosition find_texture_pos_for_glyph(FontDataForSizeFallback *p_data, int p_color_size, Image::Format p_image_format, int p_width, int p_height) const;
+#ifdef MODULE_MSDFGEN_ENABLED
+	_FORCE_INLINE_ FontGlyph rasterize_msdf(FontDataFallback *p_font_data, FontDataForSizeFallback *p_data, int p_pixel_range, int p_rect_margin, FT_Outline *outline, const Vector2 &advance) const;
+#endif
+#ifdef MODULE_FREETYPE_ENABLED
+	_FORCE_INLINE_ FontGlyph rasterize_bitmap(FontDataForSizeFallback *p_data, int p_rect_margin, FT_Bitmap bitmap, int yofs, int xofs, const Vector2 &advance) const;
+#endif
+	_FORCE_INLINE_ bool _ensure_glyph(FontDataFallback *p_font_data, const Vector2i &p_size, int32_t p_glyph) const;
+	_FORCE_INLINE_ bool _ensure_cache_for_size(FontDataFallback *p_font_data, const Vector2i &p_size) const;
+	_FORCE_INLINE_ void _font_clear_cache(FontDataFallback *p_font_data);
+	void _generateMTSDF_threaded(uint32_t y, void *p_td) const;
+
+	_FORCE_INLINE_ Vector2i _get_size(const FontDataFallback *p_font_data, int p_size) const {
+		if (p_font_data->msdf) {
+			return Vector2i(p_font_data->msdf_source_size, 0);
+		} else if (p_font_data->fixed_size > 0) {
+			return Vector2i(p_font_data->fixed_size, 0);
+		} else {
+			return Vector2i(p_size, 0);
+		}
+	}
+
+	_FORCE_INLINE_ Vector2i _get_size_outline(const FontDataFallback *p_font_data, const Vector2i &p_size) const {
+		if (p_font_data->msdf) {
+			return Vector2i(p_font_data->msdf_source_size, 0);
+		} else if (p_font_data->fixed_size > 0) {
+			return Vector2i(p_font_data->fixed_size, MIN(p_size.y, 1));
+		} else {
+			return p_size;
+		}
+	}
+
+	// Common data.
+
+	real_t oversampling = 1.f;
+	mutable RID_PtrOwner<FontDataFallback> font_owner;
+	mutable RID_PtrOwner<ShapedTextData> shaped_owner;
+
 protected:
 	static void _bind_methods(){};
 
@@ -77,72 +220,130 @@ public:
 
 	virtual bool is_locale_right_to_left(const String &p_locale) override;
 
+	virtual int32_t name_to_tag(const String &p_name) const override;
+	virtual String tag_to_name(int32_t p_tag) const 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 RID create_font_bitmap(float p_height, float p_ascent, int p_base_size = 16) override;
+	virtual RID create_font() override;
+
+	virtual void font_set_data(RID p_font_rid, const PackedByteArray &p_data) override;
+	virtual void font_set_data_ptr(RID p_font_rid, const uint8_t *p_data_ptr, size_t p_data_size) override;
+
+	virtual void font_set_antialiased(RID p_font_rid, bool p_antialiased) override;
+	virtual bool font_is_antialiased(RID p_font_rid) const override;
+
+	virtual void font_set_multichannel_signed_distance_field(RID p_font_rid, bool p_msdf) override;
+	virtual bool font_is_multichannel_signed_distance_field(RID p_font_rid) const override;
+
+	virtual void font_set_msdf_pixel_range(RID p_font_rid, int p_msdf_pixel_range) override;
+	virtual int font_get_msdf_pixel_range(RID p_font_rid) const override;
+
+	virtual void font_set_msdf_size(RID p_font_rid, int p_msdf_size) override;
+	virtual int font_get_msdf_size(RID p_font_rid) const override;
+
+	virtual void font_set_fixed_size(RID p_font_rid, int p_fixed_size) override;
+	virtual int font_get_fixed_size(RID p_font_rid) const override;
+
+	virtual void font_set_force_autohinter(RID p_font_rid, bool p_force_autohinter) override;
+	virtual bool font_is_force_autohinter(RID p_font_rid) const override;
+
+	virtual void font_set_hinting(RID p_font_rid, TextServer::Hinting p_hinting) override;
+	virtual TextServer::Hinting font_get_hinting(RID p_font_rid) const override;
+
+	virtual void font_set_variation_coordinates(RID p_font_rid, const Dictionary &p_variation_coordinates) override;
+	virtual Dictionary font_get_variation_coordinates(RID p_font_rid) const override;
+
+	virtual void font_set_oversampling(RID p_font_rid, real_t p_oversampling) override;
+	virtual real_t font_get_oversampling(RID p_font_rid) const override;
+
+	virtual Array font_get_size_cache_list(RID p_font_rid) const override;
+	virtual void font_clear_size_cache(RID p_font_rid) override;
+	virtual void font_remove_size_cache(RID p_font_rid, const Vector2i &p_size) override;
+
+	virtual void font_set_ascent(RID p_font_rid, int p_size, real_t p_ascent) override;
+	virtual real_t font_get_ascent(RID p_font_rid, int p_size) const override;
+
+	virtual void font_set_descent(RID p_font_rid, int p_size, real_t p_descent) override;
+	virtual real_t font_get_descent(RID p_font_rid, int p_size) const override;
+
+	virtual void font_set_underline_position(RID p_font_rid, int p_size, real_t p_underline_position) override;
+	virtual real_t font_get_underline_position(RID p_font_rid, int p_size) const override;
+
+	virtual void font_set_underline_thickness(RID p_font_rid, int p_size, real_t p_underline_thickness) override;
+	virtual real_t font_get_underline_thickness(RID p_font_rid, int p_size) const override;
+
+	virtual void font_set_scale(RID p_font_rid, int p_size, real_t p_scale) override;
+	virtual real_t font_get_scale(RID p_font_rid, int p_size) const override;
+
+	virtual void font_set_spacing(RID p_font_rid, int p_size, SpacingType p_spacing, int p_value) override;
+	virtual int font_get_spacing(RID p_font_rid, int p_size, SpacingType p_spacing) const override;
+
+	virtual int font_get_texture_count(RID p_font_rid, const Vector2i &p_size) const override;
+	virtual void font_clear_textures(RID p_font_rid, const Vector2i &p_size) override;
+	virtual void font_remove_texture(RID p_font_rid, const Vector2i &p_size, int p_texture_index) override;
+
+	virtual void font_set_texture_image(RID p_font_rid, const Vector2i &p_size, int p_texture_index, const Ref<Image> &p_image) override;
+	virtual Ref<Image> font_get_texture_image(RID p_font_rid, const Vector2i &p_size, int p_texture_index) const override;
 
-	virtual void font_bitmap_add_texture(RID p_font, const Ref<Texture> &p_texture) override;
-	virtual void font_bitmap_add_char(RID p_font, char32_t p_char, int p_texture_idx, const Rect2 &p_rect, const Size2 &p_align, float p_advance) override;
-	virtual void font_bitmap_add_kerning_pair(RID p_font, char32_t p_A, char32_t p_B, int p_kerning) override;
+	virtual void font_set_texture_offsets(RID p_font_rid, const Vector2i &p_size, int p_texture_index, const PackedInt32Array &p_offset) override;
+	virtual PackedInt32Array font_get_texture_offsets(RID p_font_rid, const Vector2i &p_size, int p_texture_index) const 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 Array font_get_glyph_list(RID p_font_rid, const Vector2i &p_size) const override;
+	virtual void font_clear_glyphs(RID p_font_rid, const Vector2i &p_size) override;
+	virtual void font_remove_glyph(RID p_font_rid, const Vector2i &p_size, int32_t p_glyph) 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 Vector2 font_get_glyph_advance(RID p_font_rid, int p_size, int32_t p_glyph) const override;
+	virtual void font_set_glyph_advance(RID p_font_rid, int p_size, int32_t p_glyph, const Vector2 &p_advance) override;
 
-	virtual int font_get_spacing_space(RID p_font) const override;
-	virtual void font_set_spacing_space(RID p_font, int p_value) override;
+	virtual Vector2 font_get_glyph_offset(RID p_font_rid, const Vector2i &p_size, int32_t p_glyph) const override;
+	virtual void font_set_glyph_offset(RID p_font_rid, const Vector2i &p_size, int32_t p_glyph, const Vector2 &p_offset) override;
 
-	virtual int font_get_spacing_glyph(RID p_font) const override;
-	virtual void font_set_spacing_glyph(RID p_font, int p_value) override;
+	virtual Vector2 font_get_glyph_size(RID p_font_rid, const Vector2i &p_size, int32_t p_glyph) const override;
+	virtual void font_set_glyph_size(RID p_font_rid, const Vector2i &p_size, int32_t p_glyph, const Vector2 &p_gl_size) override;
 
-	virtual void font_set_antialiased(RID p_font, bool p_antialiased) override;
-	virtual bool font_get_antialiased(RID p_font) const override;
+	virtual Rect2 font_get_glyph_uv_rect(RID p_font_rid, const Vector2i &p_size, int32_t p_glyph) const override;
+	virtual void font_set_glyph_uv_rect(RID p_font_rid, const Vector2i &p_size, int32_t p_glyph, const Rect2 &p_uv_rect) override;
 
-	virtual void font_set_hinting(RID p_font, Hinting p_hinting) override;
-	virtual Hinting font_get_hinting(RID p_font) const override;
+	virtual int font_get_glyph_texture_idx(RID p_font_rid, const Vector2i &p_size, int32_t p_glyph) const override;
+	virtual void font_set_glyph_texture_idx(RID p_font_rid, const Vector2i &p_size, int32_t p_glyph, int p_texture_idx) 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_get_glyph_contours(RID p_font, int p_size, int32_t p_index, Vector<Vector3> &r_points, Vector<int32_t> &r_contours, bool &r_orientation) 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 Array font_get_kerning_list(RID p_font_rid, int p_size) const override;
+	virtual void font_clear_kerning_map(RID p_font_rid, int p_size) override;
+	virtual void font_remove_kerning(RID p_font_rid, int p_size, const Vector2i &p_glyph_pair) 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_kerning(RID p_font_rid, int p_size, const Vector2i &p_glyph_pair, const Vector2 &p_kerning) override;
+	virtual Vector2 font_get_kerning(RID p_font_rid, int p_size, const Vector2i &p_glyph_pair) const override;
 
-	virtual bool font_has_outline(RID p_font) const override;
-	virtual float font_get_base_size(RID p_font) const override;
+	virtual int32_t font_get_glyph_index(RID p_font_rid, int p_size, char32_t p_char, char32_t p_variation_selector = 0) 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_has_char(RID p_font_rid, char32_t p_char) const override;
+	virtual String font_get_supported_chars(RID p_font_rid) const 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 void font_render_range(RID p_font, const Vector2i &p_size, char32_t p_start, char32_t p_end) override;
+	virtual void font_render_glyph(RID p_font_rid, const Vector2i &p_size, int32_t p_index) 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 void font_draw_glyph(RID p_font, RID p_canvas, int p_size, const Vector2 &p_pos, int32_t p_index, const Color &p_color = Color(1, 1, 1)) const override;
+	virtual void font_draw_glyph_outline(RID p_font, RID p_canvas, int p_size, int p_outline_size, const Vector2 &p_pos, int32_t p_index, const Color &p_color = Color(1, 1, 1)) 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 bool font_is_language_supported(RID p_font_rid, const String &p_language) const override;
+	virtual void font_set_language_support_override(RID p_font_rid, const String &p_language, bool p_supported) override;
+	virtual bool font_get_language_support_override(RID p_font_rid, const String &p_language) override;
+	virtual void font_remove_language_support_override(RID p_font_rid, const String &p_language) override;
+	virtual Vector<String> font_get_language_support_overrides(RID p_font_rid) override;
 
-	virtual bool font_get_glyph_contours(RID p_font, int p_size, uint32_t p_index, Vector<Vector3> &r_points, Vector<int32_t> &r_contours, bool &r_orientation) const override;
+	virtual bool font_is_script_supported(RID p_font_rid, const String &p_script) const override;
+	virtual void font_set_script_support_override(RID p_font_rid, const String &p_script, bool p_supported) override;
+	virtual bool font_get_script_support_override(RID p_font_rid, const String &p_script) override;
+	virtual void font_remove_script_support_override(RID p_font_rid, const String &p_script) override;
+	virtual Vector<String> font_get_script_support_overrides(RID p_font_rid) override;
 
-	virtual float font_get_oversampling() const override;
-	virtual void font_set_oversampling(float p_oversampling) override;
+	virtual Dictionary font_supported_feature_list(RID p_font_rid) const override;
+	virtual Dictionary font_supported_variation_list(RID p_font_rid) const override;
 
-	virtual Vector<String> get_system_fonts() const override;
+	virtual real_t font_get_global_oversampling() const override;
+	virtual void font_set_global_oversampling(real_t p_oversampling) override;
 
 	/* Shaped text buffer interface */
 
@@ -171,14 +372,14 @@ public:
 	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 real_t shaped_text_fit_to_width(RID p_shaped, real_t p_width, uint8_t /*JustificationFlag*/ p_jst_flags = JUSTIFICATION_WORD_BOUND | JUSTIFICATION_KASHIDA) override;
+	virtual real_t shaped_text_tab_align(RID p_shaped, const Vector<real_t> &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 void shaped_text_overrun_trim_to_width(RID p_shaped, float p_width, uint8_t p_trim_flags) override;
+	virtual void shaped_text_overrun_trim_to_width(RID p_shaped, real_t p_width, uint8_t p_trim_flags) override;
 	virtual TrimData shaped_text_get_trim_data(RID p_shaped) const override;
 
 	virtual bool shaped_text_is_ready(RID p_shaped) const override;
@@ -193,17 +394,17 @@ public:
 	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 real_t shaped_text_get_ascent(RID p_shaped) const override;
+	virtual real_t shaped_text_get_descent(RID p_shaped) const override;
+	virtual real_t shaped_text_get_width(RID p_shaped) const override;
+	virtual real_t shaped_text_get_underline_position(RID p_shaped) const override;
+	virtual real_t shaped_text_get_underline_thickness(RID p_shaped) const override;
 
 	static TextServer *create_func(Error &r_error, void *p_user_data);
 	static void register_server();
 
-	TextServerFallback(){};
-	~TextServerFallback(){};
+	TextServerFallback();
+	~TextServerFallback();
 };
 
 #endif // TEXT_SERVER_FALLBACK_H