From 8f5d56e04a60020ec8a6db2aebc9bf9bbaf727d1 Mon Sep 17 00:00:00 2001
From: bruvzg <7645683+bruvzg@users.noreply.github.com>
Date: Tue, 27 Sep 2022 11:23:34 +0300
Subject: [GDExtension] Use function names with underscore for TextServer
 extension, add macros to generate wrappers for module functions.

---
 modules/text_server_fb/text_server_fb.cpp | 476 +++++++++++++++---------------
 modules/text_server_fb/text_server_fb.h   | 336 ++++++++++-----------
 2 files changed, 413 insertions(+), 399 deletions(-)

(limited to 'modules/text_server_fb')

diff --git a/modules/text_server_fb/text_server_fb.cpp b/modules/text_server_fb/text_server_fb.cpp
index 9ef0f0ad82..e7cb1b28a8 100644
--- a/modules/text_server_fb/text_server_fb.cpp
+++ b/modules/text_server_fb/text_server_fb.cpp
@@ -33,7 +33,7 @@
 #ifdef GDEXTENSION
 // Headers for building as GDExtension plug-in.
 
-#include <godot_cpp/classes/file.hpp>
+#include <godot_cpp/classes/file_access.hpp>
 #include <godot_cpp/classes/project_settings.hpp>
 #include <godot_cpp/classes/rendering_server.hpp>
 #include <godot_cpp/classes/translation_server.hpp>
@@ -66,7 +66,7 @@ using namespace godot;
 
 #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)))
 
-bool TextServerFallback::has_feature(Feature p_feature) const {
+bool TextServerFallback::_has_feature(Feature p_feature) const {
 	switch (p_feature) {
 		case FEATURE_SIMPLE_LAYOUT:
 		case FEATURE_FONT_BITMAP:
@@ -83,7 +83,7 @@ bool TextServerFallback::has_feature(Feature p_feature) const {
 	return false;
 }
 
-String TextServerFallback::get_name() const {
+String TextServerFallback::_get_name() const {
 #ifdef GDEXTENSION
 	return "Fallback (GDExtension)";
 #else
@@ -91,7 +91,7 @@ String TextServerFallback::get_name() const {
 #endif
 }
 
-int64_t TextServerFallback::get_features() const {
+int64_t TextServerFallback::_get_features() const {
 	int64_t interface_features = FEATURE_SIMPLE_LAYOUT | FEATURE_FONT_BITMAP;
 #ifdef MODULE_FREETYPE_ENABLED
 	interface_features |= FEATURE_FONT_DYNAMIC;
@@ -103,7 +103,7 @@ int64_t TextServerFallback::get_features() const {
 	return interface_features;
 }
 
-void TextServerFallback::free_rid(const RID &p_rid) {
+void TextServerFallback::_free_rid(const RID &p_rid) {
 	_THREAD_SAFE_METHOD_
 	if (font_owner.owns(p_rid)) {
 		FontFallback *fd = font_owner.get_or_null(p_rid);
@@ -116,20 +116,28 @@ void TextServerFallback::free_rid(const RID &p_rid) {
 	}
 }
 
-bool TextServerFallback::has(const RID &p_rid) {
+bool TextServerFallback::_has(const RID &p_rid) {
 	_THREAD_SAFE_METHOD_
 	return font_owner.owns(p_rid) || shaped_owner.owns(p_rid);
 }
 
-bool TextServerFallback::load_support_data(const String &p_filename) {
+String TextServerFallback::_get_support_data_filename() const {
+	return "";
+};
+
+String TextServerFallback::_get_support_data_info() const {
+	return "Not supported";
+};
+
+bool TextServerFallback::_load_support_data(const String &p_filename) {
 	return false; // No extra data used.
 }
 
-bool TextServerFallback::save_support_data(const String &p_filename) const {
+bool TextServerFallback::_save_support_data(const String &p_filename) const {
 	return false; // No extra data used.
 }
 
-bool TextServerFallback::is_locale_right_to_left(const String &p_locale) const {
+bool TextServerFallback::_is_locale_right_to_left(const String &p_locale) const {
 	return false; // No RTL support.
 }
 
@@ -169,7 +177,7 @@ _FORCE_INLINE_ int32_t ot_tag_from_string(const char *p_str, int p_len) {
 	return OT_TAG(tag[0], tag[1], tag[2], tag[3]);
 }
 
-int64_t TextServerFallback::name_to_tag(const String &p_name) const {
+int64_t TextServerFallback::_name_to_tag(const String &p_name) const {
 	if (feature_sets.has(p_name)) {
 		return feature_sets[p_name];
 	}
@@ -185,7 +193,7 @@ _FORCE_INLINE_ void ot_tag_to_string(int32_t p_tag, char *p_buf) {
 	p_buf[3] = (char)(uint8_t)(p_tag >> 0);
 }
 
-String TextServerFallback::tag_to_name(int64_t p_tag) const {
+String TextServerFallback::_tag_to_name(int64_t p_tag) const {
 	if (feature_sets_inv.has(p_tag)) {
 		return feature_sets_inv[p_tag];
 	}
@@ -467,8 +475,14 @@ _FORCE_INLINE_ TextServerFallback::FontGlyph TextServerFallback::rasterize_msdf(
 		td.projection = &projection;
 		td.distancePixelConversion = &distancePixelConversion;
 
+#ifdef GDEXTENSION
+		for (int i = 0; i < h; i++) {
+			_generateMTSDF_threaded(i, &td);
+		}
+#else
 		WorkerThreadPool::GroupID group_id = WorkerThreadPool::get_singleton()->add_template_group_task(this, &TextServerFallback::_generateMTSDF_threaded, &td, h, -1, true, SNAME("TextServerFBRenderMSDF"));
 		WorkerThreadPool::get_singleton()->wait_for_group_task_completion(group_id);
+#endif
 
 		msdfgen::msdfErrorCorrection(image, shape, projection, p_pixel_range, config);
 
@@ -840,7 +854,7 @@ _FORCE_INLINE_ bool TextServerFallback::_ensure_cache_for_size(FontFallback *p_f
 			fd->oversampling = 1.0;
 			fd->size.x = p_font_data->msdf_source_size;
 		} else if (p_font_data->oversampling <= 0.0) {
-			fd->oversampling = font_get_global_oversampling();
+			fd->oversampling = _font_get_global_oversampling();
 		} else {
 			fd->oversampling = p_font_data->oversampling;
 		}
@@ -921,8 +935,8 @@ _FORCE_INLINE_ bool TextServerFallback::_ensure_cache_for_size(FontFallback *p_f
 					coords.write[i] = CLAMP(var_value * 65536.0, 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)];
+				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.0, amaster->axis[i].minimum, amaster->axis[i].maximum);
 				}
 			}
@@ -948,7 +962,7 @@ _FORCE_INLINE_ void TextServerFallback::_font_clear_cache(FontFallback *p_font_d
 	p_font_data->supported_varaitions.clear();
 }
 
-RID TextServerFallback::create_font() {
+RID TextServerFallback::_create_font() {
 	_THREAD_SAFE_METHOD_
 
 	FontFallback *fd = memnew(FontFallback);
@@ -956,7 +970,7 @@ RID TextServerFallback::create_font() {
 	return font_owner.make_rid(fd);
 }
 
-void TextServerFallback::font_set_data(const RID &p_font_rid, const PackedByteArray &p_data) {
+void TextServerFallback::_font_set_data(const RID &p_font_rid, const PackedByteArray &p_data) {
 	FontFallback *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND(!fd);
 
@@ -967,7 +981,7 @@ void TextServerFallback::font_set_data(const RID &p_font_rid, const PackedByteAr
 	fd->data_size = fd->data.size();
 }
 
-void TextServerFallback::font_set_data_ptr(const RID &p_font_rid, const uint8_t *p_data_ptr, int64_t p_data_size) {
+void TextServerFallback::_font_set_data_ptr(const RID &p_font_rid, const uint8_t *p_data_ptr, int64_t p_data_size) {
 	FontFallback *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND(!fd);
 
@@ -978,7 +992,7 @@ void TextServerFallback::font_set_data_ptr(const RID &p_font_rid, const uint8_t
 	fd->data_size = p_data_size;
 }
 
-void TextServerFallback::font_set_style(const RID &p_font_rid, BitField<FontStyle> p_style) {
+void TextServerFallback::_font_set_style(const RID &p_font_rid, BitField<FontStyle> p_style) {
 	FontFallback *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND(!fd);
 
@@ -988,7 +1002,7 @@ void TextServerFallback::font_set_style(const RID &p_font_rid, BitField<FontStyl
 	fd->style_flags = p_style;
 }
 
-void TextServerFallback::font_set_face_index(const RID &p_font_rid, int64_t p_face_index) {
+void TextServerFallback::_font_set_face_index(const RID &p_font_rid, int64_t p_face_index) {
 	ERR_FAIL_COND(p_face_index < 0);
 	ERR_FAIL_COND(p_face_index >= 0x7FFF);
 
@@ -1002,7 +1016,7 @@ void TextServerFallback::font_set_face_index(const RID &p_font_rid, int64_t p_fa
 	}
 }
 
-int64_t TextServerFallback::font_get_face_index(const RID &p_font_rid) const {
+int64_t TextServerFallback::_font_get_face_index(const RID &p_font_rid) const {
 	FontFallback *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND_V(!fd, 0);
 
@@ -1010,7 +1024,7 @@ int64_t TextServerFallback::font_get_face_index(const RID &p_font_rid) const {
 	return fd->face_index;
 }
 
-int64_t TextServerFallback::font_get_face_count(const RID &p_font_rid) const {
+int64_t TextServerFallback::_font_get_face_count(const RID &p_font_rid) const {
 	FontFallback *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND_V(!fd, 0);
 
@@ -1051,7 +1065,7 @@ int64_t TextServerFallback::font_get_face_count(const RID &p_font_rid) const {
 	return face_count;
 }
 
-BitField<TextServer::FontStyle> TextServerFallback::font_get_style(const RID &p_font_rid) const {
+BitField<TextServer::FontStyle> TextServerFallback::_font_get_style(const RID &p_font_rid) const {
 	FontFallback *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND_V(!fd, 0);
 
@@ -1061,7 +1075,7 @@ BitField<TextServer::FontStyle> TextServerFallback::font_get_style(const RID &p_
 	return fd->style_flags;
 }
 
-void TextServerFallback::font_set_style_name(const RID &p_font_rid, const String &p_name) {
+void TextServerFallback::_font_set_style_name(const RID &p_font_rid, const String &p_name) {
 	FontFallback *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND(!fd);
 
@@ -1071,7 +1085,7 @@ void TextServerFallback::font_set_style_name(const RID &p_font_rid, const String
 	fd->style_name = p_name;
 }
 
-String TextServerFallback::font_get_style_name(const RID &p_font_rid) const {
+String TextServerFallback::_font_get_style_name(const RID &p_font_rid) const {
 	FontFallback *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND_V(!fd, String());
 
@@ -1081,7 +1095,7 @@ String TextServerFallback::font_get_style_name(const RID &p_font_rid) const {
 	return fd->style_name;
 }
 
-void TextServerFallback::font_set_name(const RID &p_font_rid, const String &p_name) {
+void TextServerFallback::_font_set_name(const RID &p_font_rid, const String &p_name) {
 	FontFallback *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND(!fd);
 
@@ -1091,7 +1105,7 @@ void TextServerFallback::font_set_name(const RID &p_font_rid, const String &p_na
 	fd->font_name = p_name;
 }
 
-String TextServerFallback::font_get_name(const RID &p_font_rid) const {
+String TextServerFallback::_font_get_name(const RID &p_font_rid) const {
 	FontFallback *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND_V(!fd, String());
 
@@ -1101,7 +1115,7 @@ String TextServerFallback::font_get_name(const RID &p_font_rid) const {
 	return fd->font_name;
 }
 
-void TextServerFallback::font_set_antialiasing(RID p_font_rid, TextServer::FontAntialiasing p_antialiasing) {
+void TextServerFallback::_font_set_antialiasing(const RID &p_font_rid, TextServer::FontAntialiasing p_antialiasing) {
 	FontFallback *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND(!fd);
 
@@ -1112,7 +1126,7 @@ void TextServerFallback::font_set_antialiasing(RID p_font_rid, TextServer::FontA
 	}
 }
 
-TextServer::FontAntialiasing TextServerFallback::font_get_antialiasing(RID p_font_rid) const {
+TextServer::FontAntialiasing TextServerFallback::_font_get_antialiasing(const RID &p_font_rid) const {
 	FontFallback *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND_V(!fd, TextServer::FONT_ANTIALIASING_NONE);
 
@@ -1120,7 +1134,7 @@ TextServer::FontAntialiasing TextServerFallback::font_get_antialiasing(RID p_fon
 	return fd->antialiasing;
 }
 
-void TextServerFallback::font_set_generate_mipmaps(const RID &p_font_rid, bool p_generate_mipmaps) {
+void TextServerFallback::_font_set_generate_mipmaps(const RID &p_font_rid, bool p_generate_mipmaps) {
 	FontFallback *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND(!fd);
 
@@ -1135,7 +1149,7 @@ void TextServerFallback::font_set_generate_mipmaps(const RID &p_font_rid, bool p
 	}
 }
 
-bool TextServerFallback::font_get_generate_mipmaps(const RID &p_font_rid) const {
+bool TextServerFallback::_font_get_generate_mipmaps(const RID &p_font_rid) const {
 	FontFallback *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND_V(!fd, false);
 
@@ -1143,7 +1157,7 @@ bool TextServerFallback::font_get_generate_mipmaps(const RID &p_font_rid) const
 	return fd->mipmaps;
 }
 
-void TextServerFallback::font_set_multichannel_signed_distance_field(const RID &p_font_rid, bool p_msdf) {
+void TextServerFallback::_font_set_multichannel_signed_distance_field(const RID &p_font_rid, bool p_msdf) {
 	FontFallback *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND(!fd);
 
@@ -1154,7 +1168,7 @@ void TextServerFallback::font_set_multichannel_signed_distance_field(const RID &
 	}
 }
 
-bool TextServerFallback::font_is_multichannel_signed_distance_field(const RID &p_font_rid) const {
+bool TextServerFallback::_font_is_multichannel_signed_distance_field(const RID &p_font_rid) const {
 	FontFallback *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND_V(!fd, false);
 
@@ -1162,7 +1176,7 @@ bool TextServerFallback::font_is_multichannel_signed_distance_field(const RID &p
 	return fd->msdf;
 }
 
-void TextServerFallback::font_set_msdf_pixel_range(const RID &p_font_rid, int64_t p_msdf_pixel_range) {
+void TextServerFallback::_font_set_msdf_pixel_range(const RID &p_font_rid, int64_t p_msdf_pixel_range) {
 	FontFallback *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND(!fd);
 
@@ -1173,7 +1187,7 @@ void TextServerFallback::font_set_msdf_pixel_range(const RID &p_font_rid, int64_
 	}
 }
 
-int64_t TextServerFallback::font_get_msdf_pixel_range(const RID &p_font_rid) const {
+int64_t TextServerFallback::_font_get_msdf_pixel_range(const RID &p_font_rid) const {
 	FontFallback *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND_V(!fd, false);
 
@@ -1181,7 +1195,7 @@ int64_t TextServerFallback::font_get_msdf_pixel_range(const RID &p_font_rid) con
 	return fd->msdf_range;
 }
 
-void TextServerFallback::font_set_msdf_size(const RID &p_font_rid, int64_t p_msdf_size) {
+void TextServerFallback::_font_set_msdf_size(const RID &p_font_rid, int64_t p_msdf_size) {
 	FontFallback *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND(!fd);
 
@@ -1192,7 +1206,7 @@ void TextServerFallback::font_set_msdf_size(const RID &p_font_rid, int64_t p_msd
 	}
 }
 
-int64_t TextServerFallback::font_get_msdf_size(const RID &p_font_rid) const {
+int64_t TextServerFallback::_font_get_msdf_size(const RID &p_font_rid) const {
 	FontFallback *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND_V(!fd, false);
 
@@ -1200,7 +1214,7 @@ int64_t TextServerFallback::font_get_msdf_size(const RID &p_font_rid) const {
 	return fd->msdf_source_size;
 }
 
-void TextServerFallback::font_set_fixed_size(const RID &p_font_rid, int64_t p_fixed_size) {
+void TextServerFallback::_font_set_fixed_size(const RID &p_font_rid, int64_t p_fixed_size) {
 	FontFallback *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND(!fd);
 
@@ -1208,7 +1222,7 @@ void TextServerFallback::font_set_fixed_size(const RID &p_font_rid, int64_t p_fi
 	fd->fixed_size = p_fixed_size;
 }
 
-int64_t TextServerFallback::font_get_fixed_size(const RID &p_font_rid) const {
+int64_t TextServerFallback::_font_get_fixed_size(const RID &p_font_rid) const {
 	FontFallback *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND_V(!fd, false);
 
@@ -1216,7 +1230,7 @@ int64_t TextServerFallback::font_get_fixed_size(const RID &p_font_rid) const {
 	return fd->fixed_size;
 }
 
-void TextServerFallback::font_set_force_autohinter(const RID &p_font_rid, bool p_force_autohinter) {
+void TextServerFallback::_font_set_force_autohinter(const RID &p_font_rid, bool p_force_autohinter) {
 	FontFallback *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND(!fd);
 
@@ -1227,7 +1241,7 @@ void TextServerFallback::font_set_force_autohinter(const RID &p_font_rid, bool p
 	}
 }
 
-bool TextServerFallback::font_is_force_autohinter(const RID &p_font_rid) const {
+bool TextServerFallback::_font_is_force_autohinter(const RID &p_font_rid) const {
 	FontFallback *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND_V(!fd, false);
 
@@ -1235,7 +1249,7 @@ bool TextServerFallback::font_is_force_autohinter(const RID &p_font_rid) const {
 	return fd->force_autohinter;
 }
 
-void TextServerFallback::font_set_hinting(const RID &p_font_rid, TextServer::Hinting p_hinting) {
+void TextServerFallback::_font_set_hinting(const RID &p_font_rid, TextServer::Hinting p_hinting) {
 	FontFallback *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND(!fd);
 
@@ -1246,7 +1260,7 @@ void TextServerFallback::font_set_hinting(const RID &p_font_rid, TextServer::Hin
 	}
 }
 
-TextServer::Hinting TextServerFallback::font_get_hinting(const RID &p_font_rid) const {
+TextServer::Hinting TextServerFallback::_font_get_hinting(const RID &p_font_rid) const {
 	FontFallback *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND_V(!fd, HINTING_NONE);
 
@@ -1254,7 +1268,7 @@ TextServer::Hinting TextServerFallback::font_get_hinting(const RID &p_font_rid)
 	return fd->hinting;
 }
 
-void TextServerFallback::font_set_subpixel_positioning(const RID &p_font_rid, TextServer::SubpixelPositioning p_subpixel) {
+void TextServerFallback::_font_set_subpixel_positioning(const RID &p_font_rid, TextServer::SubpixelPositioning p_subpixel) {
 	FontFallback *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND(!fd);
 
@@ -1262,7 +1276,7 @@ void TextServerFallback::font_set_subpixel_positioning(const RID &p_font_rid, Te
 	fd->subpixel_positioning = p_subpixel;
 }
 
-TextServer::SubpixelPositioning TextServerFallback::font_get_subpixel_positioning(const RID &p_font_rid) const {
+TextServer::SubpixelPositioning TextServerFallback::_font_get_subpixel_positioning(const RID &p_font_rid) const {
 	FontFallback *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND_V(!fd, SUBPIXEL_POSITIONING_DISABLED);
 
@@ -1270,7 +1284,7 @@ TextServer::SubpixelPositioning TextServerFallback::font_get_subpixel_positionin
 	return fd->subpixel_positioning;
 }
 
-void TextServerFallback::font_set_embolden(const RID &p_font_rid, double p_strength) {
+void TextServerFallback::_font_set_embolden(const RID &p_font_rid, double p_strength) {
 	FontFallback *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND(!fd);
 
@@ -1281,7 +1295,7 @@ void TextServerFallback::font_set_embolden(const RID &p_font_rid, double p_stren
 	}
 }
 
-double TextServerFallback::font_get_embolden(const RID &p_font_rid) const {
+double TextServerFallback::_font_get_embolden(const RID &p_font_rid) const {
 	FontFallback *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND_V(!fd, 0.0);
 
@@ -1289,7 +1303,7 @@ double TextServerFallback::font_get_embolden(const RID &p_font_rid) const {
 	return fd->embolden;
 }
 
-void TextServerFallback::font_set_transform(const RID &p_font_rid, const Transform2D &p_transform) {
+void TextServerFallback::_font_set_transform(const RID &p_font_rid, const Transform2D &p_transform) {
 	FontFallback *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND(!fd);
 
@@ -1300,7 +1314,7 @@ void TextServerFallback::font_set_transform(const RID &p_font_rid, const Transfo
 	}
 }
 
-Transform2D TextServerFallback::font_get_transform(const RID &p_font_rid) const {
+Transform2D TextServerFallback::_font_get_transform(const RID &p_font_rid) const {
 	FontFallback *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND_V(!fd, Transform2D());
 
@@ -1308,7 +1322,7 @@ Transform2D TextServerFallback::font_get_transform(const RID &p_font_rid) const
 	return fd->transform;
 }
 
-void TextServerFallback::font_set_variation_coordinates(const RID &p_font_rid, const Dictionary &p_variation_coordinates) {
+void TextServerFallback::_font_set_variation_coordinates(const RID &p_font_rid, const Dictionary &p_variation_coordinates) {
 	FontFallback *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND(!fd);
 
@@ -1319,7 +1333,7 @@ void TextServerFallback::font_set_variation_coordinates(const RID &p_font_rid, c
 	}
 }
 
-Dictionary TextServerFallback::font_get_variation_coordinates(const RID &p_font_rid) const {
+Dictionary TextServerFallback::_font_get_variation_coordinates(const RID &p_font_rid) const {
 	FontFallback *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND_V(!fd, Dictionary());
 
@@ -1327,7 +1341,7 @@ Dictionary TextServerFallback::font_get_variation_coordinates(const RID &p_font_
 	return fd->variation_coordinates;
 }
 
-void TextServerFallback::font_set_oversampling(const RID &p_font_rid, double p_oversampling) {
+void TextServerFallback::_font_set_oversampling(const RID &p_font_rid, double p_oversampling) {
 	FontFallback *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND(!fd);
 
@@ -1338,7 +1352,7 @@ void TextServerFallback::font_set_oversampling(const RID &p_font_rid, double p_o
 	}
 }
 
-double TextServerFallback::font_get_oversampling(const RID &p_font_rid) const {
+double TextServerFallback::_font_get_oversampling(const RID &p_font_rid) const {
 	FontFallback *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND_V(!fd, 0.0);
 
@@ -1346,7 +1360,7 @@ double TextServerFallback::font_get_oversampling(const RID &p_font_rid) const {
 	return fd->oversampling;
 }
 
-TypedArray<Vector2i> TextServerFallback::font_get_size_cache_list(const RID &p_font_rid) const {
+TypedArray<Vector2i> TextServerFallback::_font_get_size_cache_list(const RID &p_font_rid) const {
 	FontFallback *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND_V(!fd, TypedArray<Vector2i>());
 
@@ -1358,7 +1372,7 @@ TypedArray<Vector2i> TextServerFallback::font_get_size_cache_list(const RID &p_f
 	return ret;
 }
 
-void TextServerFallback::font_clear_size_cache(const RID &p_font_rid) {
+void TextServerFallback::_font_clear_size_cache(const RID &p_font_rid) {
 	FontFallback *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND(!fd);
 
@@ -1369,7 +1383,7 @@ void TextServerFallback::font_clear_size_cache(const RID &p_font_rid) {
 	fd->cache.clear();
 }
 
-void TextServerFallback::font_remove_size_cache(const RID &p_font_rid, const Vector2i &p_size) {
+void TextServerFallback::_font_remove_size_cache(const RID &p_font_rid, const Vector2i &p_size) {
 	FontFallback *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND(!fd);
 
@@ -1380,7 +1394,7 @@ void TextServerFallback::font_remove_size_cache(const RID &p_font_rid, const Vec
 	}
 }
 
-void TextServerFallback::font_set_ascent(const RID &p_font_rid, int64_t p_size, double p_ascent) {
+void TextServerFallback::_font_set_ascent(const RID &p_font_rid, int64_t p_size, double p_ascent) {
 	FontFallback *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND(!fd);
 
@@ -1391,7 +1405,7 @@ void TextServerFallback::font_set_ascent(const RID &p_font_rid, int64_t p_size,
 	fd->cache[size]->ascent = p_ascent;
 }
 
-double TextServerFallback::font_get_ascent(const RID &p_font_rid, int64_t p_size) const {
+double TextServerFallback::_font_get_ascent(const RID &p_font_rid, int64_t p_size) const {
 	FontFallback *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND_V(!fd, 0.0);
 
@@ -1407,7 +1421,7 @@ double TextServerFallback::font_get_ascent(const RID &p_font_rid, int64_t p_size
 	}
 }
 
-void TextServerFallback::font_set_descent(const RID &p_font_rid, int64_t p_size, double p_descent) {
+void TextServerFallback::_font_set_descent(const RID &p_font_rid, int64_t p_size, double p_descent) {
 	FontFallback *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND(!fd);
 
@@ -1417,7 +1431,7 @@ void TextServerFallback::font_set_descent(const RID &p_font_rid, int64_t p_size,
 	fd->cache[size]->descent = p_descent;
 }
 
-double TextServerFallback::font_get_descent(const RID &p_font_rid, int64_t p_size) const {
+double TextServerFallback::_font_get_descent(const RID &p_font_rid, int64_t p_size) const {
 	FontFallback *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND_V(!fd, 0.0);
 
@@ -1433,7 +1447,7 @@ double TextServerFallback::font_get_descent(const RID &p_font_rid, int64_t p_siz
 	}
 }
 
-void TextServerFallback::font_set_underline_position(const RID &p_font_rid, int64_t p_size, double p_underline_position) {
+void TextServerFallback::_font_set_underline_position(const RID &p_font_rid, int64_t p_size, double p_underline_position) {
 	FontFallback *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND(!fd);
 
@@ -1444,7 +1458,7 @@ void TextServerFallback::font_set_underline_position(const RID &p_font_rid, int6
 	fd->cache[size]->underline_position = p_underline_position;
 }
 
-double TextServerFallback::font_get_underline_position(const RID &p_font_rid, int64_t p_size) const {
+double TextServerFallback::_font_get_underline_position(const RID &p_font_rid, int64_t p_size) const {
 	FontFallback *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND_V(!fd, 0.0);
 
@@ -1460,7 +1474,7 @@ double TextServerFallback::font_get_underline_position(const RID &p_font_rid, in
 	}
 }
 
-void TextServerFallback::font_set_underline_thickness(const RID &p_font_rid, int64_t p_size, double p_underline_thickness) {
+void TextServerFallback::_font_set_underline_thickness(const RID &p_font_rid, int64_t p_size, double p_underline_thickness) {
 	FontFallback *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND(!fd);
 
@@ -1471,7 +1485,7 @@ void TextServerFallback::font_set_underline_thickness(const RID &p_font_rid, int
 	fd->cache[size]->underline_thickness = p_underline_thickness;
 }
 
-double TextServerFallback::font_get_underline_thickness(const RID &p_font_rid, int64_t p_size) const {
+double TextServerFallback::_font_get_underline_thickness(const RID &p_font_rid, int64_t p_size) const {
 	FontFallback *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND_V(!fd, 0.0);
 
@@ -1487,7 +1501,7 @@ double TextServerFallback::font_get_underline_thickness(const RID &p_font_rid, i
 	}
 }
 
-void TextServerFallback::font_set_scale(const RID &p_font_rid, int64_t p_size, double p_scale) {
+void TextServerFallback::_font_set_scale(const RID &p_font_rid, int64_t p_size, double p_scale) {
 	FontFallback *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND(!fd);
 
@@ -1503,7 +1517,7 @@ void TextServerFallback::font_set_scale(const RID &p_font_rid, int64_t p_size, d
 	fd->cache[size]->scale = p_scale;
 }
 
-double TextServerFallback::font_get_scale(const RID &p_font_rid, int64_t p_size) const {
+double TextServerFallback::_font_get_scale(const RID &p_font_rid, int64_t p_size) const {
 	FontFallback *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND_V(!fd, 0.0);
 
@@ -1519,7 +1533,7 @@ double TextServerFallback::font_get_scale(const RID &p_font_rid, int64_t p_size)
 	}
 }
 
-int64_t TextServerFallback::font_get_texture_count(const RID &p_font_rid, const Vector2i &p_size) const {
+int64_t TextServerFallback::_font_get_texture_count(const RID &p_font_rid, const Vector2i &p_size) const {
 	FontFallback *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND_V(!fd, 0);
 
@@ -1531,7 +1545,7 @@ int64_t TextServerFallback::font_get_texture_count(const RID &p_font_rid, const
 	return fd->cache[size]->textures.size();
 }
 
-void TextServerFallback::font_clear_textures(const RID &p_font_rid, const Vector2i &p_size) {
+void TextServerFallback::_font_clear_textures(const RID &p_font_rid, const Vector2i &p_size) {
 	FontFallback *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND(!fd);
 	MutexLock lock(fd->mutex);
@@ -1541,7 +1555,7 @@ void TextServerFallback::font_clear_textures(const RID &p_font_rid, const Vector
 	fd->cache[size]->textures.clear();
 }
 
-void TextServerFallback::font_remove_texture(const RID &p_font_rid, const Vector2i &p_size, int64_t p_texture_index) {
+void TextServerFallback::_font_remove_texture(const RID &p_font_rid, const Vector2i &p_size, int64_t p_texture_index) {
 	FontFallback *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND(!fd);
 
@@ -1553,7 +1567,7 @@ void TextServerFallback::font_remove_texture(const RID &p_font_rid, const Vector
 	fd->cache[size]->textures.remove_at(p_texture_index);
 }
 
-void TextServerFallback::font_set_texture_image(const RID &p_font_rid, const Vector2i &p_size, int64_t p_texture_index, const Ref<Image> &p_image) {
+void TextServerFallback::_font_set_texture_image(const RID &p_font_rid, const Vector2i &p_size, int64_t p_texture_index, const Ref<Image> &p_image) {
 	FontFallback *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND(!fd);
 	ERR_FAIL_COND(p_image.is_null());
@@ -1584,7 +1598,7 @@ void TextServerFallback::font_set_texture_image(const RID &p_font_rid, const Vec
 	tex.dirty = false;
 }
 
-Ref<Image> TextServerFallback::font_get_texture_image(const RID &p_font_rid, const Vector2i &p_size, int64_t p_texture_index) const {
+Ref<Image> TextServerFallback::_font_get_texture_image(const RID &p_font_rid, const Vector2i &p_size, int64_t p_texture_index) const {
 	FontFallback *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND_V(!fd, Ref<Image>());
 
@@ -1601,7 +1615,7 @@ Ref<Image> TextServerFallback::font_get_texture_image(const RID &p_font_rid, con
 	return img;
 }
 
-void TextServerFallback::font_set_texture_offsets(const RID &p_font_rid, const Vector2i &p_size, int64_t p_texture_index, const PackedInt32Array &p_offset) {
+void TextServerFallback::_font_set_texture_offsets(const RID &p_font_rid, const Vector2i &p_size, int64_t p_texture_index, const PackedInt32Array &p_offset) {
 	FontFallback *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND(!fd);
 
@@ -1617,7 +1631,7 @@ void TextServerFallback::font_set_texture_offsets(const RID &p_font_rid, const V
 	tex.offsets = p_offset;
 }
 
-PackedInt32Array TextServerFallback::font_get_texture_offsets(const RID &p_font_rid, const Vector2i &p_size, int64_t p_texture_index) const {
+PackedInt32Array TextServerFallback::_font_get_texture_offsets(const RID &p_font_rid, const Vector2i &p_size, int64_t p_texture_index) const {
 	FontFallback *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND_V(!fd, PackedInt32Array());
 
@@ -1630,7 +1644,7 @@ PackedInt32Array TextServerFallback::font_get_texture_offsets(const RID &p_font_
 	return tex.offsets;
 }
 
-PackedInt32Array TextServerFallback::font_get_glyph_list(const RID &p_font_rid, const Vector2i &p_size) const {
+PackedInt32Array TextServerFallback::_font_get_glyph_list(const RID &p_font_rid, const Vector2i &p_size) const {
 	FontFallback *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND_V(!fd, PackedInt32Array());
 
@@ -1646,7 +1660,7 @@ PackedInt32Array TextServerFallback::font_get_glyph_list(const RID &p_font_rid,
 	return ret;
 }
 
-void TextServerFallback::font_clear_glyphs(const RID &p_font_rid, const Vector2i &p_size) {
+void TextServerFallback::_font_clear_glyphs(const RID &p_font_rid, const Vector2i &p_size) {
 	FontFallback *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND(!fd);
 
@@ -1657,7 +1671,7 @@ void TextServerFallback::font_clear_glyphs(const RID &p_font_rid, const Vector2i
 	fd->cache[size]->glyph_map.clear();
 }
 
-void TextServerFallback::font_remove_glyph(const RID &p_font_rid, const Vector2i &p_size, int64_t p_glyph) {
+void TextServerFallback::_font_remove_glyph(const RID &p_font_rid, const Vector2i &p_size, int64_t p_glyph) {
 	FontFallback *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND(!fd);
 
@@ -1668,7 +1682,7 @@ void TextServerFallback::font_remove_glyph(const RID &p_font_rid, const Vector2i
 	fd->cache[size]->glyph_map.erase(p_glyph);
 }
 
-Vector2 TextServerFallback::font_get_glyph_advance(const RID &p_font_rid, int64_t p_size, int64_t p_glyph) const {
+Vector2 TextServerFallback::_font_get_glyph_advance(const RID &p_font_rid, int64_t p_size, int64_t p_glyph) const {
 	FontFallback *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND_V(!fd, Vector2());
 
@@ -1679,7 +1693,7 @@ Vector2 TextServerFallback::font_get_glyph_advance(const RID &p_font_rid, int64_
 
 	int mod = 0;
 	if (fd->antialiasing == FONT_ANTIALIASING_LCD) {
-		TextServer::FontLCDSubpixelLayout layout = (TextServer::FontLCDSubpixelLayout)(int)GLOBAL_GET("gui/theme/lcd_subpixel_layout");
+		TextServer::FontLCDSubpixelLayout layout = (TextServer::FontLCDSubpixelLayout)(int)ProjectSettings::get_singleton()->get("gui/theme/lcd_subpixel_layout");
 		if (layout != FONT_LCD_SUBPIXEL_LAYOUT_NONE) {
 			mod = (layout << 24);
 		}
@@ -1705,7 +1719,7 @@ Vector2 TextServerFallback::font_get_glyph_advance(const RID &p_font_rid, int64_
 	}
 }
 
-void TextServerFallback::font_set_glyph_advance(const RID &p_font_rid, int64_t p_size, int64_t p_glyph, const Vector2 &p_advance) {
+void TextServerFallback::_font_set_glyph_advance(const RID &p_font_rid, int64_t p_size, int64_t p_glyph, const Vector2 &p_advance) {
 	FontFallback *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND(!fd);
 
@@ -1720,7 +1734,7 @@ void TextServerFallback::font_set_glyph_advance(const RID &p_font_rid, int64_t p
 	gl[p_glyph].found = true;
 }
 
-Vector2 TextServerFallback::font_get_glyph_offset(const RID &p_font_rid, const Vector2i &p_size, int64_t p_glyph) const {
+Vector2 TextServerFallback::_font_get_glyph_offset(const RID &p_font_rid, const Vector2i &p_size, int64_t p_glyph) const {
 	FontFallback *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND_V(!fd, Vector2());
 
@@ -1731,7 +1745,7 @@ Vector2 TextServerFallback::font_get_glyph_offset(const RID &p_font_rid, const V
 
 	int mod = 0;
 	if (fd->antialiasing == FONT_ANTIALIASING_LCD) {
-		TextServer::FontLCDSubpixelLayout layout = (TextServer::FontLCDSubpixelLayout)(int)GLOBAL_GET("gui/theme/lcd_subpixel_layout");
+		TextServer::FontLCDSubpixelLayout layout = (TextServer::FontLCDSubpixelLayout)(int)ProjectSettings::get_singleton()->get("gui/theme/lcd_subpixel_layout");
 		if (layout != FONT_LCD_SUBPIXEL_LAYOUT_NONE) {
 			mod = (layout << 24);
 		}
@@ -1750,7 +1764,7 @@ Vector2 TextServerFallback::font_get_glyph_offset(const RID &p_font_rid, const V
 	}
 }
 
-void TextServerFallback::font_set_glyph_offset(const RID &p_font_rid, const Vector2i &p_size, int64_t p_glyph, const Vector2 &p_offset) {
+void TextServerFallback::_font_set_glyph_offset(const RID &p_font_rid, const Vector2i &p_size, int64_t p_glyph, const Vector2 &p_offset) {
 	FontFallback *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND(!fd);
 
@@ -1765,7 +1779,7 @@ void TextServerFallback::font_set_glyph_offset(const RID &p_font_rid, const Vect
 	gl[p_glyph].found = true;
 }
 
-Vector2 TextServerFallback::font_get_glyph_size(const RID &p_font_rid, const Vector2i &p_size, int64_t p_glyph) const {
+Vector2 TextServerFallback::_font_get_glyph_size(const RID &p_font_rid, const Vector2i &p_size, int64_t p_glyph) const {
 	FontFallback *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND_V(!fd, Vector2());
 
@@ -1776,7 +1790,7 @@ Vector2 TextServerFallback::font_get_glyph_size(const RID &p_font_rid, const Vec
 
 	int mod = 0;
 	if (fd->antialiasing == FONT_ANTIALIASING_LCD) {
-		TextServer::FontLCDSubpixelLayout layout = (TextServer::FontLCDSubpixelLayout)(int)GLOBAL_GET("gui/theme/lcd_subpixel_layout");
+		TextServer::FontLCDSubpixelLayout layout = (TextServer::FontLCDSubpixelLayout)(int)ProjectSettings::get_singleton()->get("gui/theme/lcd_subpixel_layout");
 		if (layout != FONT_LCD_SUBPIXEL_LAYOUT_NONE) {
 			mod = (layout << 24);
 		}
@@ -1795,7 +1809,7 @@ Vector2 TextServerFallback::font_get_glyph_size(const RID &p_font_rid, const Vec
 	}
 }
 
-void TextServerFallback::font_set_glyph_size(const RID &p_font_rid, const Vector2i &p_size, int64_t p_glyph, const Vector2 &p_gl_size) {
+void TextServerFallback::_font_set_glyph_size(const RID &p_font_rid, const Vector2i &p_size, int64_t p_glyph, const Vector2 &p_gl_size) {
 	FontFallback *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND(!fd);
 
@@ -1810,7 +1824,7 @@ void TextServerFallback::font_set_glyph_size(const RID &p_font_rid, const Vector
 	gl[p_glyph].found = true;
 }
 
-Rect2 TextServerFallback::font_get_glyph_uv_rect(const RID &p_font_rid, const Vector2i &p_size, int64_t p_glyph) const {
+Rect2 TextServerFallback::_font_get_glyph_uv_rect(const RID &p_font_rid, const Vector2i &p_size, int64_t p_glyph) const {
 	FontFallback *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND_V(!fd, Rect2());
 
@@ -1821,7 +1835,7 @@ Rect2 TextServerFallback::font_get_glyph_uv_rect(const RID &p_font_rid, const Ve
 
 	int mod = 0;
 	if (fd->antialiasing == FONT_ANTIALIASING_LCD) {
-		TextServer::FontLCDSubpixelLayout layout = (TextServer::FontLCDSubpixelLayout)(int)GLOBAL_GET("gui/theme/lcd_subpixel_layout");
+		TextServer::FontLCDSubpixelLayout layout = (TextServer::FontLCDSubpixelLayout)(int)ProjectSettings::get_singleton()->get("gui/theme/lcd_subpixel_layout");
 		if (layout != FONT_LCD_SUBPIXEL_LAYOUT_NONE) {
 			mod = (layout << 24);
 		}
@@ -1835,7 +1849,7 @@ Rect2 TextServerFallback::font_get_glyph_uv_rect(const RID &p_font_rid, const Ve
 	return gl[p_glyph | mod].uv_rect;
 }
 
-void TextServerFallback::font_set_glyph_uv_rect(const RID &p_font_rid, const Vector2i &p_size, int64_t p_glyph, const Rect2 &p_uv_rect) {
+void TextServerFallback::_font_set_glyph_uv_rect(const RID &p_font_rid, const Vector2i &p_size, int64_t p_glyph, const Rect2 &p_uv_rect) {
 	FontFallback *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND(!fd);
 
@@ -1850,7 +1864,7 @@ void TextServerFallback::font_set_glyph_uv_rect(const RID &p_font_rid, const Vec
 	gl[p_glyph].found = true;
 }
 
-int64_t TextServerFallback::font_get_glyph_texture_idx(const RID &p_font_rid, const Vector2i &p_size, int64_t p_glyph) const {
+int64_t TextServerFallback::_font_get_glyph_texture_idx(const RID &p_font_rid, const Vector2i &p_size, int64_t p_glyph) const {
 	FontFallback *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND_V(!fd, -1);
 
@@ -1861,7 +1875,7 @@ int64_t TextServerFallback::font_get_glyph_texture_idx(const RID &p_font_rid, co
 
 	int mod = 0;
 	if (fd->antialiasing == FONT_ANTIALIASING_LCD) {
-		TextServer::FontLCDSubpixelLayout layout = (TextServer::FontLCDSubpixelLayout)(int)GLOBAL_GET("gui/theme/lcd_subpixel_layout");
+		TextServer::FontLCDSubpixelLayout layout = (TextServer::FontLCDSubpixelLayout)(int)ProjectSettings::get_singleton()->get("gui/theme/lcd_subpixel_layout");
 		if (layout != FONT_LCD_SUBPIXEL_LAYOUT_NONE) {
 			mod = (layout << 24);
 		}
@@ -1875,7 +1889,7 @@ int64_t TextServerFallback::font_get_glyph_texture_idx(const RID &p_font_rid, co
 	return gl[p_glyph | mod].texture_idx;
 }
 
-void TextServerFallback::font_set_glyph_texture_idx(const RID &p_font_rid, const Vector2i &p_size, int64_t p_glyph, int64_t p_texture_idx) {
+void TextServerFallback::_font_set_glyph_texture_idx(const RID &p_font_rid, const Vector2i &p_size, int64_t p_glyph, int64_t p_texture_idx) {
 	FontFallback *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND(!fd);
 
@@ -1890,7 +1904,7 @@ void TextServerFallback::font_set_glyph_texture_idx(const RID &p_font_rid, const
 	gl[p_glyph].found = true;
 }
 
-RID TextServerFallback::font_get_glyph_texture_rid(const RID &p_font_rid, const Vector2i &p_size, int64_t p_glyph) const {
+RID TextServerFallback::_font_get_glyph_texture_rid(const RID &p_font_rid, const Vector2i &p_size, int64_t p_glyph) const {
 	FontFallback *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND_V(!fd, RID());
 
@@ -1901,7 +1915,7 @@ RID TextServerFallback::font_get_glyph_texture_rid(const RID &p_font_rid, const
 
 	int mod = 0;
 	if (fd->antialiasing == FONT_ANTIALIASING_LCD) {
-		TextServer::FontLCDSubpixelLayout layout = (TextServer::FontLCDSubpixelLayout)(int)GLOBAL_GET("gui/theme/lcd_subpixel_layout");
+		TextServer::FontLCDSubpixelLayout layout = (TextServer::FontLCDSubpixelLayout)(int)ProjectSettings::get_singleton()->get("gui/theme/lcd_subpixel_layout");
 		if (layout != FONT_LCD_SUBPIXEL_LAYOUT_NONE) {
 			mod = (layout << 24);
 		}
@@ -1938,7 +1952,7 @@ RID TextServerFallback::font_get_glyph_texture_rid(const RID &p_font_rid, const
 	return RID();
 }
 
-Size2 TextServerFallback::font_get_glyph_texture_size(const RID &p_font_rid, const Vector2i &p_size, int64_t p_glyph) const {
+Size2 TextServerFallback::_font_get_glyph_texture_size(const RID &p_font_rid, const Vector2i &p_size, int64_t p_glyph) const {
 	FontFallback *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND_V(!fd, Size2());
 
@@ -1949,7 +1963,7 @@ Size2 TextServerFallback::font_get_glyph_texture_size(const RID &p_font_rid, con
 
 	int mod = 0;
 	if (fd->antialiasing == FONT_ANTIALIASING_LCD) {
-		TextServer::FontLCDSubpixelLayout layout = (TextServer::FontLCDSubpixelLayout)(int)GLOBAL_GET("gui/theme/lcd_subpixel_layout");
+		TextServer::FontLCDSubpixelLayout layout = (TextServer::FontLCDSubpixelLayout)(int)ProjectSettings::get_singleton()->get("gui/theme/lcd_subpixel_layout");
 		if (layout != FONT_LCD_SUBPIXEL_LAYOUT_NONE) {
 			mod = (layout << 24);
 		}
@@ -1986,7 +2000,7 @@ Size2 TextServerFallback::font_get_glyph_texture_size(const RID &p_font_rid, con
 	return Size2();
 }
 
-Dictionary TextServerFallback::font_get_glyph_contours(const RID &p_font_rid, int64_t p_size, int64_t p_index) const {
+Dictionary TextServerFallback::_font_get_glyph_contours(const RID &p_font_rid, int64_t p_size, int64_t p_index) const {
 	FontFallback *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND_V(!fd, Dictionary());
 
@@ -2036,7 +2050,7 @@ Dictionary TextServerFallback::font_get_glyph_contours(const RID &p_font_rid, in
 #endif
 }
 
-TypedArray<Vector2i> TextServerFallback::font_get_kerning_list(const RID &p_font_rid, int64_t p_size) const {
+TypedArray<Vector2i> TextServerFallback::_font_get_kerning_list(const RID &p_font_rid, int64_t p_size) const {
 	FontFallback *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND_V(!fd, TypedArray<Vector2i>());
 
@@ -2052,7 +2066,7 @@ TypedArray<Vector2i> TextServerFallback::font_get_kerning_list(const RID &p_font
 	return ret;
 }
 
-void TextServerFallback::font_clear_kerning_map(const RID &p_font_rid, int64_t p_size) {
+void TextServerFallback::_font_clear_kerning_map(const RID &p_font_rid, int64_t p_size) {
 	FontFallback *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND(!fd);
 
@@ -2063,7 +2077,7 @@ void TextServerFallback::font_clear_kerning_map(const RID &p_font_rid, int64_t p
 	fd->cache[size]->kerning_map.clear();
 }
 
-void TextServerFallback::font_remove_kerning(const RID &p_font_rid, int64_t p_size, const Vector2i &p_glyph_pair) {
+void TextServerFallback::_font_remove_kerning(const RID &p_font_rid, int64_t p_size, const Vector2i &p_glyph_pair) {
 	FontFallback *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND(!fd);
 
@@ -2074,7 +2088,7 @@ void TextServerFallback::font_remove_kerning(const RID &p_font_rid, int64_t p_si
 	fd->cache[size]->kerning_map.erase(p_glyph_pair);
 }
 
-void TextServerFallback::font_set_kerning(const RID &p_font_rid, int64_t p_size, const Vector2i &p_glyph_pair, const Vector2 &p_kerning) {
+void TextServerFallback::_font_set_kerning(const RID &p_font_rid, int64_t p_size, const Vector2i &p_glyph_pair, const Vector2 &p_kerning) {
 	FontFallback *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND(!fd);
 
@@ -2085,7 +2099,7 @@ void TextServerFallback::font_set_kerning(const RID &p_font_rid, int64_t p_size,
 	fd->cache[size]->kerning_map[p_glyph_pair] = p_kerning;
 }
 
-Vector2 TextServerFallback::font_get_kerning(const RID &p_font_rid, int64_t p_size, const Vector2i &p_glyph_pair) const {
+Vector2 TextServerFallback::_font_get_kerning(const RID &p_font_rid, int64_t p_size, const Vector2i &p_glyph_pair) const {
 	FontFallback *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND_V(!fd, Vector2());
 
@@ -2120,12 +2134,12 @@ Vector2 TextServerFallback::font_get_kerning(const RID &p_font_rid, int64_t p_si
 	return Vector2();
 }
 
-int64_t TextServerFallback::font_get_glyph_index(const RID &p_font_rid, int64_t p_size, int64_t p_char, int64_t p_variation_selector) const {
+int64_t TextServerFallback::_font_get_glyph_index(const RID &p_font_rid, int64_t p_size, int64_t p_char, int64_t p_variation_selector) const {
 	ERR_FAIL_COND_V_MSG((p_char >= 0xd800 && p_char <= 0xdfff) || (p_char > 0x10ffff), 0, "Unicode parsing error: Invalid unicode codepoint " + String::num_int64(p_char, 16) + ".");
 	return (int64_t)p_char;
 }
 
-bool TextServerFallback::font_has_char(const RID &p_font_rid, int64_t p_char) const {
+bool TextServerFallback::_font_has_char(const RID &p_font_rid, int64_t p_char) const {
 	FontFallback *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND_V_MSG((p_char >= 0xd800 && p_char <= 0xdfff) || (p_char > 0x10ffff), false, "Unicode parsing error: Invalid unicode codepoint " + String::num_int64(p_char, 16) + ".");
 	if (!fd) {
@@ -2146,7 +2160,7 @@ bool TextServerFallback::font_has_char(const RID &p_font_rid, int64_t p_char) co
 	return (at_size) ? at_size->glyph_map.has((int32_t)p_char) : false;
 }
 
-String TextServerFallback::font_get_supported_chars(const RID &p_font_rid) const {
+String TextServerFallback::_font_get_supported_chars(const RID &p_font_rid) const {
 	FontFallback *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND_V(!fd, String());
 
@@ -2179,7 +2193,7 @@ String TextServerFallback::font_get_supported_chars(const RID &p_font_rid) const
 	return chars;
 }
 
-void TextServerFallback::font_render_range(const RID &p_font_rid, const Vector2i &p_size, int64_t p_start, int64_t p_end) {
+void TextServerFallback::_font_render_range(const RID &p_font_rid, const Vector2i &p_size, int64_t p_start, int64_t p_end) {
 	FontFallback *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND(!fd);
 	ERR_FAIL_COND_MSG((p_start >= 0xd800 && p_start <= 0xdfff) || (p_start > 0x10ffff), "Unicode parsing error: Invalid unicode codepoint " + String::num_int64(p_start, 16) + ".");
@@ -2214,7 +2228,7 @@ void TextServerFallback::font_render_range(const RID &p_font_rid, const Vector2i
 	}
 }
 
-void TextServerFallback::font_render_glyph(const RID &p_font_rid, const Vector2i &p_size, int64_t p_index) {
+void TextServerFallback::_font_render_glyph(const RID &p_font_rid, const Vector2i &p_size, int64_t p_index) {
 	FontFallback *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND(!fd);
 
@@ -2245,7 +2259,7 @@ void TextServerFallback::font_render_glyph(const RID &p_font_rid, const Vector2i
 #endif
 }
 
-void TextServerFallback::font_draw_glyph(const RID &p_font_rid, const RID &p_canvas, int64_t p_size, const Vector2 &p_pos, int64_t p_index, const Color &p_color) const {
+void TextServerFallback::_font_draw_glyph(const RID &p_font_rid, const RID &p_canvas, int64_t p_size, const Vector2 &p_pos, int64_t p_index, const Color &p_color) const {
 	FontFallback *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND(!fd);
 
@@ -2260,7 +2274,7 @@ void TextServerFallback::font_draw_glyph(const RID &p_font_rid, const RID &p_can
 	if (!fd->msdf && fd->cache[size]->face) {
 		// LCD layout, bits 24, 25, 26
 		if (fd->antialiasing == FONT_ANTIALIASING_LCD) {
-			TextServer::FontLCDSubpixelLayout layout = (TextServer::FontLCDSubpixelLayout)(int)GLOBAL_GET("gui/theme/lcd_subpixel_layout");
+			TextServer::FontLCDSubpixelLayout layout = (TextServer::FontLCDSubpixelLayout)(int)ProjectSettings::get_singleton()->get("gui/theme/lcd_subpixel_layout");
 			if (layout != FONT_LCD_SUBPIXEL_LAYOUT_NONE) {
 				lcd_aa = true;
 				index = index | (layout << 24);
@@ -2337,7 +2351,7 @@ void TextServerFallback::font_draw_glyph(const RID &p_font_rid, const RID &p_can
 	}
 }
 
-void TextServerFallback::font_draw_glyph_outline(const RID &p_font_rid, const RID &p_canvas, int64_t p_size, int64_t p_outline_size, const Vector2 &p_pos, int64_t p_index, const Color &p_color) const {
+void TextServerFallback::_font_draw_glyph_outline(const RID &p_font_rid, const RID &p_canvas, int64_t p_size, int64_t p_outline_size, const Vector2 &p_pos, int64_t p_index, const Color &p_color) const {
 	FontFallback *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND(!fd);
 
@@ -2352,7 +2366,7 @@ void TextServerFallback::font_draw_glyph_outline(const RID &p_font_rid, const RI
 	if (!fd->msdf && fd->cache[size]->face) {
 		// LCD layout, bits 24, 25, 26
 		if (fd->antialiasing == FONT_ANTIALIASING_LCD) {
-			TextServer::FontLCDSubpixelLayout layout = (TextServer::FontLCDSubpixelLayout)(int)GLOBAL_GET("gui/theme/lcd_subpixel_layout");
+			TextServer::FontLCDSubpixelLayout layout = (TextServer::FontLCDSubpixelLayout)(int)ProjectSettings::get_singleton()->get("gui/theme/lcd_subpixel_layout");
 			if (layout != FONT_LCD_SUBPIXEL_LAYOUT_NONE) {
 				lcd_aa = true;
 				index = index | (layout << 24);
@@ -2429,7 +2443,7 @@ void TextServerFallback::font_draw_glyph_outline(const RID &p_font_rid, const RI
 	}
 }
 
-bool TextServerFallback::font_is_language_supported(const RID &p_font_rid, const String &p_language) const {
+bool TextServerFallback::_font_is_language_supported(const RID &p_font_rid, const String &p_language) const {
 	FontFallback *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND_V(!fd, false);
 
@@ -2441,7 +2455,7 @@ bool TextServerFallback::font_is_language_supported(const RID &p_font_rid, const
 	}
 }
 
-void TextServerFallback::font_set_language_support_override(const RID &p_font_rid, const String &p_language, bool p_supported) {
+void TextServerFallback::_font_set_language_support_override(const RID &p_font_rid, const String &p_language, bool p_supported) {
 	FontFallback *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND(!fd);
 
@@ -2449,7 +2463,7 @@ void TextServerFallback::font_set_language_support_override(const RID &p_font_ri
 	fd->language_support_overrides[p_language] = p_supported;
 }
 
-bool TextServerFallback::font_get_language_support_override(const RID &p_font_rid, const String &p_language) {
+bool TextServerFallback::_font_get_language_support_override(const RID &p_font_rid, const String &p_language) {
 	FontFallback *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND_V(!fd, false);
 
@@ -2457,7 +2471,7 @@ bool TextServerFallback::font_get_language_support_override(const RID &p_font_ri
 	return fd->language_support_overrides[p_language];
 }
 
-void TextServerFallback::font_remove_language_support_override(const RID &p_font_rid, const String &p_language) {
+void TextServerFallback::_font_remove_language_support_override(const RID &p_font_rid, const String &p_language) {
 	FontFallback *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND(!fd);
 
@@ -2465,7 +2479,7 @@ void TextServerFallback::font_remove_language_support_override(const RID &p_font
 	fd->language_support_overrides.erase(p_language);
 }
 
-PackedStringArray TextServerFallback::font_get_language_support_overrides(const RID &p_font_rid) {
+PackedStringArray TextServerFallback::_font_get_language_support_overrides(const RID &p_font_rid) {
 	FontFallback *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND_V(!fd, PackedStringArray());
 
@@ -2477,7 +2491,7 @@ PackedStringArray TextServerFallback::font_get_language_support_overrides(const
 	return out;
 }
 
-bool TextServerFallback::font_is_script_supported(const RID &p_font_rid, const String &p_script) const {
+bool TextServerFallback::_font_is_script_supported(const RID &p_font_rid, const String &p_script) const {
 	FontFallback *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND_V(!fd, false);
 
@@ -2489,7 +2503,7 @@ bool TextServerFallback::font_is_script_supported(const RID &p_font_rid, const S
 	}
 }
 
-void TextServerFallback::font_set_script_support_override(const RID &p_font_rid, const String &p_script, bool p_supported) {
+void TextServerFallback::_font_set_script_support_override(const RID &p_font_rid, const String &p_script, bool p_supported) {
 	FontFallback *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND(!fd);
 
@@ -2497,7 +2511,7 @@ void TextServerFallback::font_set_script_support_override(const RID &p_font_rid,
 	fd->script_support_overrides[p_script] = p_supported;
 }
 
-bool TextServerFallback::font_get_script_support_override(const RID &p_font_rid, const String &p_script) {
+bool TextServerFallback::_font_get_script_support_override(const RID &p_font_rid, const String &p_script) {
 	FontFallback *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND_V(!fd, false);
 
@@ -2505,7 +2519,7 @@ bool TextServerFallback::font_get_script_support_override(const RID &p_font_rid,
 	return fd->script_support_overrides[p_script];
 }
 
-void TextServerFallback::font_remove_script_support_override(const RID &p_font_rid, const String &p_script) {
+void TextServerFallback::_font_remove_script_support_override(const RID &p_font_rid, const String &p_script) {
 	FontFallback *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND(!fd);
 
@@ -2515,7 +2529,7 @@ void TextServerFallback::font_remove_script_support_override(const RID &p_font_r
 	fd->script_support_overrides.erase(p_script);
 }
 
-PackedStringArray TextServerFallback::font_get_script_support_overrides(const RID &p_font_rid) {
+PackedStringArray TextServerFallback::_font_get_script_support_overrides(const RID &p_font_rid) {
 	FontFallback *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND_V(!fd, PackedStringArray());
 
@@ -2527,7 +2541,7 @@ PackedStringArray TextServerFallback::font_get_script_support_overrides(const RI
 	return out;
 }
 
-void TextServerFallback::font_set_opentype_feature_overrides(const RID &p_font_rid, const Dictionary &p_overrides) {
+void TextServerFallback::_font_set_opentype_feature_overrides(const RID &p_font_rid, const Dictionary &p_overrides) {
 	FontFallback *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND(!fd);
 
@@ -2537,7 +2551,7 @@ void TextServerFallback::font_set_opentype_feature_overrides(const RID &p_font_r
 	fd->feature_overrides = p_overrides;
 }
 
-Dictionary TextServerFallback::font_get_opentype_feature_overrides(const RID &p_font_rid) const {
+Dictionary TextServerFallback::_font_get_opentype_feature_overrides(const RID &p_font_rid) const {
 	FontFallback *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND_V(!fd, Dictionary());
 
@@ -2545,11 +2559,11 @@ Dictionary TextServerFallback::font_get_opentype_feature_overrides(const RID &p_
 	return fd->feature_overrides;
 }
 
-Dictionary TextServerFallback::font_supported_feature_list(const RID &p_font_rid) const {
+Dictionary TextServerFallback::_font_supported_feature_list(const RID &p_font_rid) const {
 	return Dictionary();
 }
 
-Dictionary TextServerFallback::font_supported_variation_list(const RID &p_font_rid) const {
+Dictionary TextServerFallback::_font_supported_variation_list(const RID &p_font_rid) const {
 	FontFallback *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND_V(!fd, Dictionary());
 
@@ -2559,11 +2573,11 @@ Dictionary TextServerFallback::font_supported_variation_list(const RID &p_font_r
 	return fd->supported_varaitions;
 }
 
-double TextServerFallback::font_get_global_oversampling() const {
+double TextServerFallback::_font_get_global_oversampling() const {
 	return oversampling;
 }
 
-void TextServerFallback::font_set_global_oversampling(double p_oversampling) {
+void TextServerFallback::_font_set_global_oversampling(double p_oversampling) {
 	_THREAD_SAFE_METHOD_
 	if (oversampling != p_oversampling) {
 		oversampling = p_oversampling;
@@ -2571,8 +2585,8 @@ void TextServerFallback::font_set_global_oversampling(double p_oversampling) {
 		font_owner.get_owned_list(&fonts);
 		bool font_cleared = false;
 		for (const RID &E : fonts) {
-			if (!font_is_multichannel_signed_distance_field(E) && font_get_oversampling(E) <= 0) {
-				font_clear_size_cache(E);
+			if (!_font_is_multichannel_signed_distance_field(E) && _font_get_oversampling(E) <= 0) {
+				_font_clear_size_cache(E);
 				font_cleared = true;
 			}
 		}
@@ -2627,7 +2641,7 @@ void TextServerFallback::full_copy(ShapedTextDataFallback *p_shaped) {
 	p_shaped->parent = RID();
 }
 
-RID TextServerFallback::create_shaped_text(TextServer::Direction p_direction, TextServer::Orientation p_orientation) {
+RID TextServerFallback::_create_shaped_text(TextServer::Direction p_direction, TextServer::Orientation p_orientation) {
 	_THREAD_SAFE_METHOD_
 
 	ShapedTextDataFallback *sd = memnew(ShapedTextDataFallback);
@@ -2637,7 +2651,7 @@ RID TextServerFallback::create_shaped_text(TextServer::Direction p_direction, Te
 	return shaped_owner.make_rid(sd);
 }
 
-void TextServerFallback::shaped_text_clear(const RID &p_shaped) {
+void TextServerFallback::_shaped_text_clear(const RID &p_shaped) {
 	ShapedTextDataFallback *sd = shaped_owner.get_or_null(p_shaped);
 	ERR_FAIL_COND(!sd);
 
@@ -2651,21 +2665,21 @@ void TextServerFallback::shaped_text_clear(const RID &p_shaped) {
 	invalidate(sd);
 }
 
-void TextServerFallback::shaped_text_set_direction(const RID &p_shaped, TextServer::Direction p_direction) {
+void TextServerFallback::_shaped_text_set_direction(const RID &p_shaped, TextServer::Direction p_direction) {
 	if (p_direction == DIRECTION_RTL) {
 		ERR_PRINT_ONCE("Right-to-left layout is not supported by this text server.");
 	}
 }
 
-TextServer::Direction TextServerFallback::shaped_text_get_direction(const RID &p_shaped) const {
+TextServer::Direction TextServerFallback::_shaped_text_get_direction(const RID &p_shaped) const {
 	return TextServer::DIRECTION_LTR;
 }
 
-TextServer::Direction TextServerFallback::shaped_text_get_inferred_direction(const RID &p_shaped) const {
+TextServer::Direction TextServerFallback::_shaped_text_get_inferred_direction(const RID &p_shaped) const {
 	return TextServer::DIRECTION_LTR;
 }
 
-void TextServerFallback::shaped_text_set_custom_punctuation(const RID &p_shaped, const String &p_punct) {
+void TextServerFallback::_shaped_text_set_custom_punctuation(const RID &p_shaped, const String &p_punct) {
 	_THREAD_SAFE_METHOD_
 	ShapedTextDataFallback *sd = shaped_owner.get_or_null(p_shaped);
 	ERR_FAIL_COND(!sd);
@@ -2679,14 +2693,14 @@ void TextServerFallback::shaped_text_set_custom_punctuation(const RID &p_shaped,
 	}
 }
 
-String TextServerFallback::shaped_text_get_custom_punctuation(const RID &p_shaped) const {
+String TextServerFallback::_shaped_text_get_custom_punctuation(const RID &p_shaped) const {
 	_THREAD_SAFE_METHOD_
 	const ShapedTextDataFallback *sd = shaped_owner.get_or_null(p_shaped);
 	ERR_FAIL_COND_V(!sd, String());
 	return sd->custom_punct;
 }
 
-void TextServerFallback::shaped_text_set_orientation(const RID &p_shaped, TextServer::Orientation p_orientation) {
+void TextServerFallback::_shaped_text_set_orientation(const RID &p_shaped, TextServer::Orientation p_orientation) {
 	ShapedTextDataFallback *sd = shaped_owner.get_or_null(p_shaped);
 	ERR_FAIL_COND(!sd);
 
@@ -2700,11 +2714,11 @@ void TextServerFallback::shaped_text_set_orientation(const RID &p_shaped, TextSe
 	}
 }
 
-void TextServerFallback::shaped_text_set_bidi_override(const RID &p_shaped, const Array &p_override) {
+void TextServerFallback::_shaped_text_set_bidi_override(const RID &p_shaped, const Array &p_override) {
 	// No BiDi support, ignore.
 }
 
-TextServer::Orientation TextServerFallback::shaped_text_get_orientation(const RID &p_shaped) const {
+TextServer::Orientation TextServerFallback::_shaped_text_get_orientation(const RID &p_shaped) const {
 	const ShapedTextDataFallback *sd = shaped_owner.get_or_null(p_shaped);
 	ERR_FAIL_COND_V(!sd, TextServer::ORIENTATION_HORIZONTAL);
 
@@ -2712,7 +2726,7 @@ TextServer::Orientation TextServerFallback::shaped_text_get_orientation(const RI
 	return sd->orientation;
 }
 
-void TextServerFallback::shaped_text_set_preserve_invalid(const RID &p_shaped, bool p_enabled) {
+void TextServerFallback::_shaped_text_set_preserve_invalid(const RID &p_shaped, bool p_enabled) {
 	ShapedTextDataFallback *sd = shaped_owner.get_or_null(p_shaped);
 
 	MutexLock lock(sd->mutex);
@@ -2726,7 +2740,7 @@ void TextServerFallback::shaped_text_set_preserve_invalid(const RID &p_shaped, b
 	}
 }
 
-bool TextServerFallback::shaped_text_get_preserve_invalid(const RID &p_shaped) const {
+bool TextServerFallback::_shaped_text_get_preserve_invalid(const RID &p_shaped) const {
 	const ShapedTextDataFallback *sd = shaped_owner.get_or_null(p_shaped);
 	ERR_FAIL_COND_V(!sd, false);
 
@@ -2734,7 +2748,7 @@ bool TextServerFallback::shaped_text_get_preserve_invalid(const RID &p_shaped) c
 	return sd->preserve_invalid;
 }
 
-void TextServerFallback::shaped_text_set_preserve_control(const RID &p_shaped, bool p_enabled) {
+void TextServerFallback::_shaped_text_set_preserve_control(const RID &p_shaped, bool p_enabled) {
 	ShapedTextDataFallback *sd = shaped_owner.get_or_null(p_shaped);
 	ERR_FAIL_COND(!sd);
 
@@ -2748,7 +2762,7 @@ void TextServerFallback::shaped_text_set_preserve_control(const RID &p_shaped, b
 	}
 }
 
-bool TextServerFallback::shaped_text_get_preserve_control(const RID &p_shaped) const {
+bool TextServerFallback::_shaped_text_get_preserve_control(const RID &p_shaped) const {
 	const ShapedTextDataFallback *sd = shaped_owner.get_or_null(p_shaped);
 	ERR_FAIL_COND_V(!sd, false);
 
@@ -2756,7 +2770,7 @@ bool TextServerFallback::shaped_text_get_preserve_control(const RID &p_shaped) c
 	return sd->preserve_control;
 }
 
-void TextServerFallback::shaped_text_set_spacing(const RID &p_shaped, SpacingType p_spacing, int64_t p_value) {
+void TextServerFallback::_shaped_text_set_spacing(const RID &p_shaped, SpacingType p_spacing, int64_t p_value) {
 	ERR_FAIL_INDEX((int)p_spacing, 4);
 	ShapedTextDataFallback *sd = shaped_owner.get_or_null(p_shaped);
 	ERR_FAIL_COND(!sd);
@@ -2771,7 +2785,7 @@ void TextServerFallback::shaped_text_set_spacing(const RID &p_shaped, SpacingTyp
 	}
 }
 
-int64_t TextServerFallback::shaped_text_get_spacing(const RID &p_shaped, SpacingType p_spacing) const {
+int64_t TextServerFallback::_shaped_text_get_spacing(const RID &p_shaped, SpacingType p_spacing) const {
 	ERR_FAIL_INDEX_V((int)p_spacing, 4, 0);
 
 	const ShapedTextDataFallback *sd = shaped_owner.get_or_null(p_shaped);
@@ -2781,20 +2795,20 @@ int64_t TextServerFallback::shaped_text_get_spacing(const RID &p_shaped, Spacing
 	return sd->extra_spacing[p_spacing];
 }
 
-int64_t TextServerFallback::shaped_get_span_count(const RID &p_shaped) const {
+int64_t TextServerFallback::_shaped_get_span_count(const RID &p_shaped) const {
 	ShapedTextDataFallback *sd = shaped_owner.get_or_null(p_shaped);
 	ERR_FAIL_COND_V(!sd, 0);
 	return sd->spans.size();
 }
 
-Variant TextServerFallback::shaped_get_span_meta(const RID &p_shaped, int64_t p_index) const {
+Variant TextServerFallback::_shaped_get_span_meta(const RID &p_shaped, int64_t p_index) const {
 	ShapedTextDataFallback *sd = shaped_owner.get_or_null(p_shaped);
 	ERR_FAIL_COND_V(!sd, Variant());
 	ERR_FAIL_INDEX_V(p_index, sd->spans.size(), Variant());
 	return sd->spans[p_index].meta;
 }
 
-void TextServerFallback::shaped_set_span_update_font(const RID &p_shaped, int64_t p_index, const TypedArray<RID> &p_fonts, int64_t p_size, const Dictionary &p_opentype_features) {
+void TextServerFallback::_shaped_set_span_update_font(const RID &p_shaped, int64_t p_index, const TypedArray<RID> &p_fonts, int64_t p_size, const Dictionary &p_opentype_features) {
 	ShapedTextDataFallback *sd = shaped_owner.get_or_null(p_shaped);
 	ERR_FAIL_COND(!sd);
 	ERR_FAIL_INDEX(p_index, sd->spans.size());
@@ -2805,7 +2819,7 @@ void TextServerFallback::shaped_set_span_update_font(const RID &p_shaped, int64_
 	Array fonts_no_match;
 	int font_count = p_fonts.size();
 	for (int i = 0; i < font_count; i++) {
-		if (font_is_language_supported(p_fonts[i], span.language)) {
+		if (_font_is_language_supported(p_fonts[i], span.language)) {
 			span.fonts.push_back(p_fonts[i]);
 		} else {
 			fonts_no_match.push_back(p_fonts[i]);
@@ -2818,7 +2832,7 @@ void TextServerFallback::shaped_set_span_update_font(const RID &p_shaped, int64_
 	sd->valid = false;
 }
 
-bool TextServerFallback::shaped_text_add_string(const RID &p_shaped, const String &p_text, const TypedArray<RID> &p_fonts, int64_t p_size, const Dictionary &p_opentype_features, const String &p_language, const Variant &p_meta) {
+bool TextServerFallback::_shaped_text_add_string(const RID &p_shaped, const String &p_text, const TypedArray<RID> &p_fonts, int64_t p_size, const Dictionary &p_opentype_features, const String &p_language, const Variant &p_meta) {
 	ShapedTextDataFallback *sd = shaped_owner.get_or_null(p_shaped);
 	ERR_FAIL_COND_V(!sd, false);
 
@@ -2848,7 +2862,7 @@ bool TextServerFallback::shaped_text_add_string(const RID &p_shaped, const Strin
 		span.fonts.push_back(p_fonts[0]);
 	}
 	for (int i = 1; i < font_count; i++) {
-		if (font_is_language_supported(p_fonts[i], p_language)) {
+		if (_font_is_language_supported(p_fonts[i], p_language)) {
 			span.fonts.push_back(p_fonts[i]);
 		} else {
 			fonts_no_match.push_back(p_fonts[i]);
@@ -2869,7 +2883,7 @@ bool TextServerFallback::shaped_text_add_string(const RID &p_shaped, const Strin
 	return true;
 }
 
-bool TextServerFallback::shaped_text_add_object(const RID &p_shaped, const Variant &p_key, const Size2 &p_size, InlineAlignment p_inline_align, int64_t p_length) {
+bool TextServerFallback::_shaped_text_add_object(const RID &p_shaped, const Variant &p_key, const Size2 &p_size, InlineAlignment p_inline_align, int64_t p_length) {
 	ShapedTextDataFallback *sd = shaped_owner.get_or_null(p_shaped);
 	ERR_FAIL_COND_V(!sd, false);
 
@@ -2900,7 +2914,7 @@ bool TextServerFallback::shaped_text_add_object(const RID &p_shaped, const Varia
 	return true;
 }
 
-bool TextServerFallback::shaped_text_resize_object(const RID &p_shaped, const Variant &p_key, const Size2 &p_size, InlineAlignment p_inline_align) {
+bool TextServerFallback::_shaped_text_resize_object(const RID &p_shaped, const Variant &p_key, const Size2 &p_size, InlineAlignment p_inline_align) {
 	ShapedTextDataFallback *sd = shaped_owner.get_or_null(p_shaped);
 	ERR_FAIL_COND_V(!sd, false);
 
@@ -2941,14 +2955,14 @@ bool TextServerFallback::shaped_text_resize_object(const RID &p_shaped, const Va
 			} else {
 				if (gl.font_rid.is_valid()) {
 					if (sd->orientation == ORIENTATION_HORIZONTAL) {
-						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));
+						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(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->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));
+					sd->upos = MAX(sd->upos, _font_get_underline_position(gl.font_rid, gl.font_size));
+					sd->uthk = MAX(sd->uthk, _font_get_underline_thickness(gl.font_rid, gl.font_size));
 				} else if (sd->preserve_invalid || (sd->preserve_control && is_control(gl.index))) {
 					// Glyph not found, replace with hex code box.
 					if (sd->orientation == ORIENTATION_HORIZONTAL) {
@@ -3035,7 +3049,7 @@ void TextServerFallback::_realign(ShapedTextDataFallback *p_sd) const {
 	p_sd->descent = full_descent;
 }
 
-RID TextServerFallback::shaped_text_substr(const RID &p_shaped, int64_t p_start, int64_t p_length) const {
+RID TextServerFallback::_shaped_text_substr(const RID &p_shaped, int64_t p_start, int64_t p_length) const {
 	_THREAD_SAFE_METHOD_
 
 	const ShapedTextDataFallback *sd = shaped_owner.get_or_null(p_shaped);
@@ -3043,10 +3057,10 @@ RID TextServerFallback::shaped_text_substr(const RID &p_shaped, int64_t p_start,
 
 	MutexLock lock(sd->mutex);
 	if (sd->parent != RID()) {
-		return shaped_text_substr(sd->parent, p_start, p_length);
+		return _shaped_text_substr(sd->parent, p_start, p_length);
 	}
 	if (!sd->valid) {
-		const_cast<TextServerFallback *>(this)->shaped_text_shape(p_shaped);
+		const_cast<TextServerFallback *>(this)->_shaped_text_shape(p_shaped);
 	}
 	ERR_FAIL_COND_V(p_start < 0 || p_length < 0, RID());
 	ERR_FAIL_COND_V(sd->start > p_start || sd->end < p_start, RID());
@@ -3101,11 +3115,11 @@ RID TextServerFallback::shaped_text_substr(const RID &p_shaped, int64_t p_start,
 				} else {
 					if (gl.font_rid.is_valid()) {
 						if (new_sd->orientation == ORIENTATION_HORIZONTAL) {
-							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));
+							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(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));
+							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.
@@ -3129,7 +3143,7 @@ RID TextServerFallback::shaped_text_substr(const RID &p_shaped, int64_t p_start,
 	return shaped_owner.make_rid(new_sd);
 }
 
-RID TextServerFallback::shaped_text_get_parent(const RID &p_shaped) const {
+RID TextServerFallback::_shaped_text_get_parent(const RID &p_shaped) const {
 	ShapedTextDataFallback *sd = shaped_owner.get_or_null(p_shaped);
 	ERR_FAIL_COND_V(!sd, RID());
 
@@ -3137,16 +3151,16 @@ RID TextServerFallback::shaped_text_get_parent(const RID &p_shaped) const {
 	return sd->parent;
 }
 
-double TextServerFallback::shaped_text_fit_to_width(const RID &p_shaped, double p_width, BitField<JustificationFlag> p_jst_flags) {
+double TextServerFallback::_shaped_text_fit_to_width(const RID &p_shaped, double p_width, BitField<JustificationFlag> p_jst_flags) {
 	ShapedTextDataFallback *sd = shaped_owner.get_or_null(p_shaped);
 	ERR_FAIL_COND_V(!sd, 0.0);
 
 	MutexLock lock(sd->mutex);
 	if (!sd->valid) {
-		const_cast<TextServerFallback *>(this)->shaped_text_shape(p_shaped);
+		const_cast<TextServerFallback *>(this)->_shaped_text_shape(p_shaped);
 	}
 	if (!sd->justification_ops_valid) {
-		const_cast<TextServerFallback *>(this)->shaped_text_update_justification_ops(p_shaped);
+		const_cast<TextServerFallback *>(this)->_shaped_text_update_justification_ops(p_shaped);
 	}
 
 	int start_pos = 0;
@@ -3246,16 +3260,16 @@ double TextServerFallback::shaped_text_fit_to_width(const RID &p_shaped, double
 	return Math::ceil(justification_width);
 }
 
-double TextServerFallback::shaped_text_tab_align(const RID &p_shaped, const PackedFloat32Array &p_tab_stops) {
+double TextServerFallback::_shaped_text_tab_align(const RID &p_shaped, const PackedFloat32Array &p_tab_stops) {
 	ShapedTextDataFallback *sd = shaped_owner.get_or_null(p_shaped);
 	ERR_FAIL_COND_V(!sd, 0.0);
 
 	MutexLock lock(sd->mutex);
 	if (!sd->valid) {
-		const_cast<TextServerFallback *>(this)->shaped_text_shape(p_shaped);
+		const_cast<TextServerFallback *>(this)->_shaped_text_shape(p_shaped);
 	}
 	if (!sd->line_breaks_valid) {
-		const_cast<TextServerFallback *>(this)->shaped_text_update_breaks(p_shaped);
+		const_cast<TextServerFallback *>(this)->_shaped_text_update_breaks(p_shaped);
 	}
 
 	for (int i = 0; i < p_tab_stops.size(); i++) {
@@ -3302,13 +3316,13 @@ double TextServerFallback::shaped_text_tab_align(const RID &p_shaped, const Pack
 	return 0.0;
 }
 
-bool TextServerFallback::shaped_text_update_breaks(const RID &p_shaped) {
+bool TextServerFallback::_shaped_text_update_breaks(const RID &p_shaped) {
 	ShapedTextDataFallback *sd = shaped_owner.get_or_null(p_shaped);
 	ERR_FAIL_COND_V(!sd, false);
 
 	MutexLock lock(sd->mutex);
 	if (!sd->valid) {
-		shaped_text_shape(p_shaped);
+		_shaped_text_shape(p_shaped);
 	}
 
 	if (sd->line_breaks_valid) {
@@ -3358,29 +3372,29 @@ bool TextServerFallback::shaped_text_update_breaks(const RID &p_shaped) {
 	return sd->line_breaks_valid;
 }
 
-bool TextServerFallback::shaped_text_update_justification_ops(const RID &p_shaped) {
+bool TextServerFallback::_shaped_text_update_justification_ops(const RID &p_shaped) {
 	ShapedTextDataFallback *sd = shaped_owner.get_or_null(p_shaped);
 	ERR_FAIL_COND_V(!sd, false);
 
 	MutexLock lock(sd->mutex);
 	if (!sd->valid) {
-		shaped_text_shape(p_shaped);
+		_shaped_text_shape(p_shaped);
 	}
 	if (!sd->line_breaks_valid) {
-		shaped_text_update_breaks(p_shaped);
+		_shaped_text_update_breaks(p_shaped);
 	}
 
 	sd->justification_ops_valid = true; // Not supported by fallback server.
 	return true;
 }
 
-void TextServerFallback::shaped_text_overrun_trim_to_width(const RID &p_shaped_line, double p_width, BitField<TextServer::TextOverrunFlag> p_trim_flags) {
+void TextServerFallback::_shaped_text_overrun_trim_to_width(const RID &p_shaped_line, double p_width, BitField<TextServer::TextOverrunFlag> p_trim_flags) {
 	ShapedTextDataFallback *sd = shaped_owner.get_or_null(p_shaped_line);
 	ERR_FAIL_COND_MSG(!sd, "ShapedTextDataFallback invalid.");
 
 	MutexLock lock(sd->mutex);
 	if (!sd->valid) {
-		shaped_text_shape(p_shaped_line);
+		_shaped_text_shape(p_shaped_line);
 	}
 
 	sd->text_trimmed = false;
@@ -3419,30 +3433,30 @@ void TextServerFallback::shaped_text_overrun_trim_to_width(const RID &p_shaped_l
 
 	// Find usable fonts, if fonts from the last glyph do not have required chars.
 	RID dot_gl_font_rid = sd_glyphs[sd_size - 1].font_rid;
-	if (!font_has_char(dot_gl_font_rid, '.')) {
+	if (!_font_has_char(dot_gl_font_rid, '.')) {
 		const Array &fonts = spans[spans.size() - 1].fonts;
 		for (int i = 0; i < fonts.size(); i++) {
-			if (font_has_char(fonts[i], '.')) {
+			if (_font_has_char(fonts[i], '.')) {
 				dot_gl_font_rid = fonts[i];
 				break;
 			}
 		}
 	}
 	RID whitespace_gl_font_rid = sd_glyphs[sd_size - 1].font_rid;
-	if (!font_has_char(whitespace_gl_font_rid, '.')) {
+	if (!_font_has_char(whitespace_gl_font_rid, '.')) {
 		const Array &fonts = spans[spans.size() - 1].fonts;
 		for (int i = 0; i < fonts.size(); i++) {
-			if (font_has_char(fonts[i], ' ')) {
+			if (_font_has_char(fonts[i], ' ')) {
 				whitespace_gl_font_rid = fonts[i];
 				break;
 			}
 		}
 	}
 
-	int32_t dot_gl_idx = dot_gl_font_rid.is_valid() ? font_get_glyph_index(dot_gl_font_rid, last_gl_font_size, '.') : -10;
-	Vector2 dot_adv = dot_gl_font_rid.is_valid() ? font_get_glyph_advance(dot_gl_font_rid, last_gl_font_size, dot_gl_idx) : Vector2();
-	int32_t whitespace_gl_idx = whitespace_gl_font_rid.is_valid() ? font_get_glyph_index(whitespace_gl_font_rid, last_gl_font_size, ' ') : -10;
-	Vector2 whitespace_adv = whitespace_gl_font_rid.is_valid() ? font_get_glyph_advance(whitespace_gl_font_rid, last_gl_font_size, whitespace_gl_idx) : Vector2();
+	int32_t dot_gl_idx = dot_gl_font_rid.is_valid() ? _font_get_glyph_index(dot_gl_font_rid, last_gl_font_size, '.', 0) : -10;
+	Vector2 dot_adv = dot_gl_font_rid.is_valid() ? _font_get_glyph_advance(dot_gl_font_rid, last_gl_font_size, dot_gl_idx) : Vector2();
+	int32_t whitespace_gl_idx = whitespace_gl_font_rid.is_valid() ? _font_get_glyph_index(whitespace_gl_font_rid, last_gl_font_size, ' ', 0) : -10;
+	Vector2 whitespace_adv = whitespace_gl_font_rid.is_valid() ? _font_get_glyph_advance(whitespace_gl_font_rid, last_gl_font_size, whitespace_gl_idx) : Vector2();
 
 	int ellipsis_width = 0;
 	if (add_ellipsis && whitespace_gl_font_rid.is_valid()) {
@@ -3531,7 +3545,7 @@ void TextServerFallback::shaped_text_overrun_trim_to_width(const RID &p_shaped_l
 	}
 }
 
-int64_t TextServerFallback::shaped_text_get_trim_pos(const RID &p_shaped) const {
+int64_t TextServerFallback::_shaped_text_get_trim_pos(const RID &p_shaped) const {
 	ShapedTextDataFallback *sd = shaped_owner.get_or_null(p_shaped);
 	ERR_FAIL_COND_V_MSG(!sd, -1, "ShapedTextDataFallback invalid.");
 
@@ -3539,7 +3553,7 @@ int64_t TextServerFallback::shaped_text_get_trim_pos(const RID &p_shaped) const
 	return sd->overrun_trim_data.trim_pos;
 }
 
-int64_t TextServerFallback::shaped_text_get_ellipsis_pos(const RID &p_shaped) const {
+int64_t TextServerFallback::_shaped_text_get_ellipsis_pos(const RID &p_shaped) const {
 	ShapedTextDataFallback *sd = shaped_owner.get_or_null(p_shaped);
 	ERR_FAIL_COND_V_MSG(!sd, -1, "ShapedTextDataFallback invalid.");
 
@@ -3547,7 +3561,7 @@ int64_t TextServerFallback::shaped_text_get_ellipsis_pos(const RID &p_shaped) co
 	return sd->overrun_trim_data.ellipsis_pos;
 }
 
-const Glyph *TextServerFallback::shaped_text_get_ellipsis_glyphs(const RID &p_shaped) const {
+const Glyph *TextServerFallback::_shaped_text_get_ellipsis_glyphs(const RID &p_shaped) const {
 	ShapedTextDataFallback *sd = shaped_owner.get_or_null(p_shaped);
 	ERR_FAIL_COND_V_MSG(!sd, nullptr, "ShapedTextDataFallback invalid.");
 
@@ -3555,7 +3569,7 @@ const Glyph *TextServerFallback::shaped_text_get_ellipsis_glyphs(const RID &p_sh
 	return sd->overrun_trim_data.ellipsis_glyph_buf.ptr();
 }
 
-int64_t TextServerFallback::shaped_text_get_ellipsis_glyph_count(const RID &p_shaped) const {
+int64_t TextServerFallback::_shaped_text_get_ellipsis_glyph_count(const RID &p_shaped) const {
 	ShapedTextDataFallback *sd = shaped_owner.get_or_null(p_shaped);
 	ERR_FAIL_COND_V_MSG(!sd, 0, "ShapedTextDataFallback invalid.");
 
@@ -3563,7 +3577,7 @@ int64_t TextServerFallback::shaped_text_get_ellipsis_glyph_count(const RID &p_sh
 	return sd->overrun_trim_data.ellipsis_glyph_buf.size();
 }
 
-bool TextServerFallback::shaped_text_shape(const RID &p_shaped) {
+bool TextServerFallback::_shaped_text_shape(const RID &p_shaped) {
 	ShapedTextDataFallback *sd = shaped_owner.get_or_null(p_shaped);
 	ERR_FAIL_COND_V(!sd, false);
 
@@ -3630,27 +3644,27 @@ bool TextServerFallback::shaped_text_shape(const 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++) {
-					if (font_has_char(span.fonts[k], gl.index)) {
+					if (_font_has_char(span.fonts[k], gl.index)) {
 						gl.font_rid = span.fonts[k];
 						break;
 					}
 				}
 
 				if (gl.font_rid.is_valid()) {
-					bool subpos = (font_get_subpixel_positioning(gl.font_rid) == SUBPIXEL_POSITIONING_ONE_HALF) || (font_get_subpixel_positioning(gl.font_rid) == SUBPIXEL_POSITIONING_ONE_QUARTER) || (font_get_subpixel_positioning(gl.font_rid) == SUBPIXEL_POSITIONING_AUTO && gl.font_size <= SUBPIXEL_POSITIONING_ONE_HALF_MAX_SIZE);
+					bool subpos = (_font_get_subpixel_positioning(gl.font_rid) == SUBPIXEL_POSITIONING_ONE_HALF) || (_font_get_subpixel_positioning(gl.font_rid) == SUBPIXEL_POSITIONING_ONE_QUARTER) || (_font_get_subpixel_positioning(gl.font_rid) == SUBPIXEL_POSITIONING_AUTO && gl.font_size <= SUBPIXEL_POSITIONING_ONE_HALF_MAX_SIZE);
 					if (sd->text[j - sd->start] != 0 && !is_linebreak(sd->text[j - sd->start])) {
 						if (sd->orientation == ORIENTATION_HORIZONTAL) {
-							gl.advance = Math::round(font_get_glyph_advance(gl.font_rid, gl.font_size, gl.index).x);
+							gl.advance = Math::round(_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, font_get_ascent(gl.font_rid, gl.font_size));
-							sd->descent = MAX(sd->descent, font_get_descent(gl.font_rid, 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 = Math::round(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));
+							gl.advance = Math::round(_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 (j < sd->end - 1) {
@@ -3661,17 +3675,17 @@ bool TextServerFallback::shaped_text_shape(const RID &p_shaped) {
 							gl.advance += sd->extra_spacing[SPACING_GLYPH];
 						}
 					}
-					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));
+					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 += font_get_kerning(gl.font_rid, gl.font_size, Vector2i(prev_gl.index, gl.index)).x;
+								prev_gl.advance += _font_get_kerning(gl.font_rid, gl.font_size, Vector2i(prev_gl.index, gl.index)).x;
 							} else {
-								prev_gl.advance += font_get_kerning(gl.font_rid, gl.font_size, Vector2i(prev_gl.index, gl.index)).y;
+								prev_gl.advance += _font_get_kerning(gl.font_rid, gl.font_size, Vector2i(prev_gl.index, gl.index)).y;
 							}
 						}
 					}
@@ -3702,7 +3716,7 @@ bool TextServerFallback::shaped_text_shape(const RID &p_shaped) {
 	return sd->valid;
 }
 
-bool TextServerFallback::shaped_text_is_ready(const RID &p_shaped) const {
+bool TextServerFallback::_shaped_text_is_ready(const RID &p_shaped) const {
 	const ShapedTextDataFallback *sd = shaped_owner.get_or_null(p_shaped);
 	ERR_FAIL_COND_V(!sd, false);
 
@@ -3710,41 +3724,41 @@ bool TextServerFallback::shaped_text_is_ready(const RID &p_shaped) const {
 	return sd->valid;
 }
 
-const Glyph *TextServerFallback::shaped_text_get_glyphs(const RID &p_shaped) const {
+const Glyph *TextServerFallback::_shaped_text_get_glyphs(const RID &p_shaped) const {
 	const ShapedTextDataFallback *sd = shaped_owner.get_or_null(p_shaped);
 	ERR_FAIL_COND_V(!sd, nullptr);
 
 	MutexLock lock(sd->mutex);
 	if (!sd->valid) {
-		const_cast<TextServerFallback *>(this)->shaped_text_shape(p_shaped);
+		const_cast<TextServerFallback *>(this)->_shaped_text_shape(p_shaped);
 	}
 	return sd->glyphs.ptr();
 }
 
-int64_t TextServerFallback::shaped_text_get_glyph_count(const RID &p_shaped) const {
+int64_t TextServerFallback::_shaped_text_get_glyph_count(const RID &p_shaped) const {
 	const ShapedTextDataFallback *sd = shaped_owner.get_or_null(p_shaped);
 	ERR_FAIL_COND_V(!sd, 0);
 
 	MutexLock lock(sd->mutex);
 	if (!sd->valid) {
-		const_cast<TextServerFallback *>(this)->shaped_text_shape(p_shaped);
+		const_cast<TextServerFallback *>(this)->_shaped_text_shape(p_shaped);
 	}
 	return sd->glyphs.size();
 }
 
-const Glyph *TextServerFallback::shaped_text_sort_logical(const RID &p_shaped) {
+const Glyph *TextServerFallback::_shaped_text_sort_logical(const RID &p_shaped) {
 	const ShapedTextDataFallback *sd = shaped_owner.get_or_null(p_shaped);
 	ERR_FAIL_COND_V(!sd, nullptr);
 
 	MutexLock lock(sd->mutex);
 	if (!sd->valid) {
-		const_cast<TextServerFallback *>(this)->shaped_text_shape(p_shaped);
+		const_cast<TextServerFallback *>(this)->_shaped_text_shape(p_shaped);
 	}
 
 	return sd->glyphs.ptr(); // Already in the logical order, return as is.
 }
 
-Vector2i TextServerFallback::shaped_text_get_range(const RID &p_shaped) const {
+Vector2i TextServerFallback::_shaped_text_get_range(const RID &p_shaped) const {
 	const ShapedTextDataFallback *sd = shaped_owner.get_or_null(p_shaped);
 	ERR_FAIL_COND_V(!sd, Vector2i());
 
@@ -3752,7 +3766,7 @@ Vector2i TextServerFallback::shaped_text_get_range(const RID &p_shaped) const {
 	return Vector2(sd->start, sd->end);
 }
 
-Array TextServerFallback::shaped_text_get_objects(const RID &p_shaped) const {
+Array TextServerFallback::_shaped_text_get_objects(const RID &p_shaped) const {
 	Array ret;
 	const ShapedTextDataFallback *sd = shaped_owner.get_or_null(p_shaped);
 	ERR_FAIL_COND_V(!sd, ret);
@@ -3765,25 +3779,25 @@ Array TextServerFallback::shaped_text_get_objects(const RID &p_shaped) const {
 	return ret;
 }
 
-Rect2 TextServerFallback::shaped_text_get_object_rect(const RID &p_shaped, const Variant &p_key) const {
+Rect2 TextServerFallback::_shaped_text_get_object_rect(const RID &p_shaped, const Variant &p_key) const {
 	const ShapedTextDataFallback *sd = shaped_owner.get_or_null(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);
+		const_cast<TextServerFallback *>(this)->_shaped_text_shape(p_shaped);
 	}
 	return sd->objects[p_key].rect;
 }
 
-Size2 TextServerFallback::shaped_text_get_size(const RID &p_shaped) const {
+Size2 TextServerFallback::_shaped_text_get_size(const RID &p_shaped) const {
 	const ShapedTextDataFallback *sd = shaped_owner.get_or_null(p_shaped);
 	ERR_FAIL_COND_V(!sd, Size2());
 
 	MutexLock lock(sd->mutex);
 	if (!sd->valid) {
-		const_cast<TextServerFallback *>(this)->shaped_text_shape(p_shaped);
+		const_cast<TextServerFallback *>(this)->_shaped_text_shape(p_shaped);
 	}
 	if (sd->orientation == TextServer::ORIENTATION_HORIZONTAL) {
 		return Size2(sd->width, sd->ascent + sd->descent + sd->extra_spacing[SPACING_TOP] + sd->extra_spacing[SPACING_BOTTOM]).ceil();
@@ -3792,64 +3806,64 @@ Size2 TextServerFallback::shaped_text_get_size(const RID &p_shaped) const {
 	}
 }
 
-double TextServerFallback::shaped_text_get_ascent(const RID &p_shaped) const {
+double TextServerFallback::_shaped_text_get_ascent(const RID &p_shaped) const {
 	const ShapedTextDataFallback *sd = shaped_owner.get_or_null(p_shaped);
 	ERR_FAIL_COND_V(!sd, 0.0);
 
 	MutexLock lock(sd->mutex);
 	if (!sd->valid) {
-		const_cast<TextServerFallback *>(this)->shaped_text_shape(p_shaped);
+		const_cast<TextServerFallback *>(this)->_shaped_text_shape(p_shaped);
 	}
 	return sd->ascent + sd->extra_spacing[SPACING_TOP];
 }
 
-double TextServerFallback::shaped_text_get_descent(const RID &p_shaped) const {
+double TextServerFallback::_shaped_text_get_descent(const RID &p_shaped) const {
 	const ShapedTextDataFallback *sd = shaped_owner.get_or_null(p_shaped);
 	ERR_FAIL_COND_V(!sd, 0.0);
 
 	MutexLock lock(sd->mutex);
 	if (!sd->valid) {
-		const_cast<TextServerFallback *>(this)->shaped_text_shape(p_shaped);
+		const_cast<TextServerFallback *>(this)->_shaped_text_shape(p_shaped);
 	}
 	return sd->descent + sd->extra_spacing[SPACING_BOTTOM];
 }
 
-double TextServerFallback::shaped_text_get_width(const RID &p_shaped) const {
+double TextServerFallback::_shaped_text_get_width(const RID &p_shaped) const {
 	const ShapedTextDataFallback *sd = shaped_owner.get_or_null(p_shaped);
 	ERR_FAIL_COND_V(!sd, 0.0);
 
 	MutexLock lock(sd->mutex);
 	if (!sd->valid) {
-		const_cast<TextServerFallback *>(this)->shaped_text_shape(p_shaped);
+		const_cast<TextServerFallback *>(this)->_shaped_text_shape(p_shaped);
 	}
 	return Math::ceil(sd->width);
 }
 
-double TextServerFallback::shaped_text_get_underline_position(const RID &p_shaped) const {
+double TextServerFallback::_shaped_text_get_underline_position(const RID &p_shaped) const {
 	const ShapedTextDataFallback *sd = shaped_owner.get_or_null(p_shaped);
 	ERR_FAIL_COND_V(!sd, 0.0);
 
 	MutexLock lock(sd->mutex);
 	if (!sd->valid) {
-		const_cast<TextServerFallback *>(this)->shaped_text_shape(p_shaped);
+		const_cast<TextServerFallback *>(this)->_shaped_text_shape(p_shaped);
 	}
 
 	return sd->upos;
 }
 
-double TextServerFallback::shaped_text_get_underline_thickness(const RID &p_shaped) const {
+double TextServerFallback::_shaped_text_get_underline_thickness(const RID &p_shaped) const {
 	const ShapedTextDataFallback *sd = shaped_owner.get_or_null(p_shaped);
 	ERR_FAIL_COND_V(!sd, 0.0);
 
 	MutexLock lock(sd->mutex);
 	if (!sd->valid) {
-		const_cast<TextServerFallback *>(this)->shaped_text_shape(p_shaped);
+		const_cast<TextServerFallback *>(this)->_shaped_text_shape(p_shaped);
 	}
 
 	return sd->uthk;
 }
 
-String TextServerFallback::string_to_upper(const String &p_string, const String &p_language) const {
+String TextServerFallback::_string_to_upper(const String &p_string, const String &p_language) const {
 	String upper = p_string;
 
 	for (int i = 0; i <= upper.length(); i++) {
@@ -3863,7 +3877,7 @@ String TextServerFallback::string_to_upper(const String &p_string, const String
 	return upper;
 }
 
-String TextServerFallback::string_to_lower(const String &p_string, const String &p_language) const {
+String TextServerFallback::_string_to_lower(const String &p_string, const String &p_language) const {
 	String lower = p_string;
 
 	for (int i = 0; i <= lower.length(); i++) {
@@ -3877,7 +3891,7 @@ String TextServerFallback::string_to_lower(const String &p_string, const String
 	return lower;
 }
 
-PackedInt32Array TextServerFallback::string_get_word_breaks(const String &p_string, const String &p_language) const {
+PackedInt32Array TextServerFallback::_string_get_word_breaks(const String &p_string, const String &p_language) const {
 	PackedInt32Array ret;
 	for (int i = 0; i < p_string.length(); i++) {
 		char32_t c = p_string[i];
diff --git a/modules/text_server_fb/text_server_fb.h b/modules/text_server_fb/text_server_fb.h
index 42f311f5ad..4aeec4f452 100644
--- a/modules/text_server_fb/text_server_fb.h
+++ b/modules/text_server_fb/text_server_fb.h
@@ -42,6 +42,7 @@
 #include <godot_cpp/godot.hpp>
 
 #include <godot_cpp/core/class_db.hpp>
+#include <godot_cpp/core/ext_wrappers.gen.inc>
 #include <godot_cpp/core/mutex_lock.hpp>
 
 #include <godot_cpp/variant/array.hpp>
@@ -80,6 +81,7 @@ using namespace godot;
 
 #include "servers/text/text_server_extension.h"
 
+#include "core/extension/ext_wrappers.gen.inc"
 #include "core/object/worker_thread_pool.h"
 #include "core/templates/hash_map.h"
 #include "core/templates/rid_owner.h"
@@ -338,251 +340,249 @@ protected:
 	void invalidate(ShapedTextDataFallback *p_shaped);
 
 public:
-	virtual bool has_feature(Feature p_feature) const override;
-	virtual String get_name() const override;
-	virtual int64_t get_features() const override;
+	MODBIND1RC(bool, has_feature, Feature);
+	MODBIND0RC(String, get_name);
+	MODBIND0RC(int64_t, get_features);
 
-	virtual void free_rid(const RID &p_rid) override;
-	virtual bool has(const RID &p_rid) override;
-	virtual bool load_support_data(const String &p_filename) override;
+	MODBIND1(free_rid, const RID &);
+	MODBIND1R(bool, has, const RID &);
+	MODBIND1R(bool, load_support_data, const String &);
 
-	virtual String get_support_data_filename() const override {
-		return "";
-	};
-	virtual String get_support_data_info() const override {
-		return "Not supported";
-	};
-	virtual bool save_support_data(const String &p_filename) const override;
+	MODBIND0RC(String, get_support_data_filename);
+	MODBIND0RC(String, get_support_data_info);
+	MODBIND1RC(bool, save_support_data, const String &);
 
-	virtual bool is_locale_right_to_left(const String &p_locale) const override;
+	MODBIND1RC(bool, is_locale_right_to_left, const String &);
 
-	virtual int64_t name_to_tag(const String &p_name) const override;
-	virtual String tag_to_name(int64_t p_tag) const override;
+	MODBIND1RC(int64_t, name_to_tag, const String &);
+	MODBIND1RC(String, tag_to_name, int64_t);
 
 	/* Font interface */
-	virtual RID create_font() override;
 
-	virtual void font_set_data(const RID &p_font_rid, const PackedByteArray &p_data) override;
-	virtual void font_set_data_ptr(const RID &p_font_rid, const uint8_t *p_data_ptr, int64_t p_data_size) override;
+	MODBIND0R(RID, create_font);
+
+	MODBIND2(font_set_data, const RID &, const PackedByteArray &);
+	MODBIND3(font_set_data_ptr, const RID &, const uint8_t *, int64_t);
+
+	MODBIND2(font_set_face_index, const RID &, int64_t);
+	MODBIND1RC(int64_t, font_get_face_index, const RID &);
 
-	virtual void font_set_face_index(const RID &p_font_rid, int64_t p_index) override;
-	virtual int64_t font_get_face_index(const RID &p_font_rid) const override;
+	MODBIND1RC(int64_t, font_get_face_count, const RID &);
 
-	virtual int64_t font_get_face_count(const RID &p_font_rid) const override;
+	MODBIND2(font_set_style, const RID &, BitField<FontStyle>);
+	MODBIND1RC(BitField<FontStyle>, font_get_style, const RID &);
 
-	virtual void font_set_style(const RID &p_font_rid, BitField<FontStyle> p_style) override;
-	virtual BitField<FontStyle> font_get_style(const RID &p_font_rid) const override;
+	MODBIND2(font_set_style_name, const RID &, const String &);
+	MODBIND1RC(String, font_get_style_name, const RID &);
 
-	virtual void font_set_style_name(const RID &p_font_rid, const String &p_name) override;
-	virtual String font_get_style_name(const RID &p_font_rid) const override;
+	MODBIND2(font_set_name, const RID &, const String &);
+	MODBIND1RC(String, font_get_name, const RID &);
 
-	virtual void font_set_name(const RID &p_font_rid, const String &p_name) override;
-	virtual String font_get_name(const RID &p_font_rid) const override;
+	MODBIND2(font_set_antialiasing, const RID &, TextServer::FontAntialiasing);
+	MODBIND1RC(TextServer::FontAntialiasing, font_get_antialiasing, const RID &);
 
-	virtual void font_set_antialiasing(RID p_font_rid, TextServer::FontAntialiasing p_antialiasing) override;
-	virtual TextServer::FontAntialiasing font_get_antialiasing(RID p_font_rid) const override;
+	MODBIND2(font_set_generate_mipmaps, const RID &, bool);
+	MODBIND1RC(bool, font_get_generate_mipmaps, const RID &);
 
-	virtual void font_set_generate_mipmaps(const RID &p_font_rid, bool p_generate_mipmaps) override;
-	virtual bool font_get_generate_mipmaps(const RID &p_font_rid) const override;
+	MODBIND2(font_set_multichannel_signed_distance_field, const RID &, bool);
+	MODBIND1RC(bool, font_is_multichannel_signed_distance_field, const RID &);
 
-	virtual void font_set_multichannel_signed_distance_field(const RID &p_font_rid, bool p_msdf) override;
-	virtual bool font_is_multichannel_signed_distance_field(const RID &p_font_rid) const override;
+	MODBIND2(font_set_msdf_pixel_range, const RID &, int64_t);
+	MODBIND1RC(int64_t, font_get_msdf_pixel_range, const RID &);
 
-	virtual void font_set_msdf_pixel_range(const RID &p_font_rid, int64_t p_msdf_pixel_range) override;
-	virtual int64_t font_get_msdf_pixel_range(const RID &p_font_rid) const override;
+	MODBIND2(font_set_msdf_size, const RID &, int64_t);
+	MODBIND1RC(int64_t, font_get_msdf_size, const RID &);
 
-	virtual void font_set_msdf_size(const RID &p_font_rid, int64_t p_msdf_size) override;
-	virtual int64_t font_get_msdf_size(const RID &p_font_rid) const override;
+	MODBIND2(font_set_fixed_size, const RID &, int64_t);
+	MODBIND1RC(int64_t, font_get_fixed_size, const RID &);
 
-	virtual void font_set_fixed_size(const RID &p_font_rid, int64_t p_fixed_size) override;
-	virtual int64_t font_get_fixed_size(const RID &p_font_rid) const override;
+	MODBIND2(font_set_force_autohinter, const RID &, bool);
+	MODBIND1RC(bool, font_is_force_autohinter, const RID &);
 
-	virtual void font_set_force_autohinter(const RID &p_font_rid, bool p_force_autohinter) override;
-	virtual bool font_is_force_autohinter(const RID &p_font_rid) const override;
+	MODBIND2(font_set_subpixel_positioning, const RID &, SubpixelPositioning);
+	MODBIND1RC(SubpixelPositioning, font_get_subpixel_positioning, const RID &);
 
-	virtual void font_set_hinting(const RID &p_font_rid, TextServer::Hinting p_hinting) override;
-	virtual TextServer::Hinting font_get_hinting(const RID &p_font_rid) const override;
+	MODBIND2(font_set_embolden, const RID &, double);
+	MODBIND1RC(double, font_get_embolden, const RID &);
 
-	virtual void font_set_subpixel_positioning(const RID &p_font_rid, SubpixelPositioning p_subpixel) override;
-	virtual SubpixelPositioning font_get_subpixel_positioning(const RID &p_font_rid) const override;
+	MODBIND2(font_set_transform, const RID &, const Transform2D &);
+	MODBIND1RC(Transform2D, font_get_transform, const RID &);
 
-	virtual void font_set_embolden(const RID &p_font_rid, double p_strength) override;
-	virtual double font_get_embolden(const RID &p_font_rid) const override;
+	MODBIND2(font_set_variation_coordinates, const RID &, const Dictionary &);
+	MODBIND1RC(Dictionary, font_get_variation_coordinates, const RID &);
 
-	virtual void font_set_transform(const RID &p_font_rid, const Transform2D &p_transform) override;
-	virtual Transform2D font_get_transform(const RID &p_font_rid) const override;
+	MODBIND2(font_set_hinting, const RID &, TextServer::Hinting);
+	MODBIND1RC(TextServer::Hinting, font_get_hinting, const RID &);
 
-	virtual void font_set_variation_coordinates(const RID &p_font_rid, const Dictionary &p_variation_coordinates) override;
-	virtual Dictionary font_get_variation_coordinates(const RID &p_font_rid) const override;
+	MODBIND2(font_set_oversampling, const RID &, double);
+	MODBIND1RC(double, font_get_oversampling, const RID &);
 
-	virtual void font_set_oversampling(const RID &p_font_rid, double p_oversampling) override;
-	virtual double font_get_oversampling(const RID &p_font_rid) const override;
+	MODBIND1RC(TypedArray<Vector2i>, font_get_size_cache_list, const RID &);
+	MODBIND1(font_clear_size_cache, const RID &);
+	MODBIND2(font_remove_size_cache, const RID &, const Vector2i &);
 
-	virtual TypedArray<Vector2i> font_get_size_cache_list(const RID &p_font_rid) const override;
-	virtual void font_clear_size_cache(const RID &p_font_rid) override;
-	virtual void font_remove_size_cache(const RID &p_font_rid, const Vector2i &p_size) override;
+	MODBIND3(font_set_ascent, const RID &, int64_t, double);
+	MODBIND2RC(double, font_get_ascent, const RID &, int64_t);
 
-	virtual void font_set_ascent(const RID &p_font_rid, int64_t p_size, double p_ascent) override;
-	virtual double font_get_ascent(const RID &p_font_rid, int64_t p_size) const override;
+	MODBIND3(font_set_descent, const RID &, int64_t, double);
+	MODBIND2RC(double, font_get_descent, const RID &, int64_t);
 
-	virtual void font_set_descent(const RID &p_font_rid, int64_t p_size, double p_descent) override;
-	virtual double font_get_descent(const RID &p_font_rid, int64_t p_size) const override;
+	MODBIND3(font_set_underline_position, const RID &, int64_t, double);
+	MODBIND2RC(double, font_get_underline_position, const RID &, int64_t);
 
-	virtual void font_set_underline_position(const RID &p_font_rid, int64_t p_size, double p_underline_position) override;
-	virtual double font_get_underline_position(const RID &p_font_rid, int64_t p_size) const override;
+	MODBIND3(font_set_underline_thickness, const RID &, int64_t, double);
+	MODBIND2RC(double, font_get_underline_thickness, const RID &, int64_t);
 
-	virtual void font_set_underline_thickness(const RID &p_font_rid, int64_t p_size, double p_underline_thickness) override;
-	virtual double font_get_underline_thickness(const RID &p_font_rid, int64_t p_size) const override;
+	MODBIND3(font_set_scale, const RID &, int64_t, double);
+	MODBIND2RC(double, font_get_scale, const RID &, int64_t);
 
-	virtual void font_set_scale(const RID &p_font_rid, int64_t p_size, double p_scale) override;
-	virtual double font_get_scale(const RID &p_font_rid, int64_t p_size) const override;
+	MODBIND2RC(int64_t, font_get_texture_count, const RID &, const Vector2i &);
+	MODBIND2(font_clear_textures, const RID &, const Vector2i &);
+	MODBIND3(font_remove_texture, const RID &, const Vector2i &, int64_t);
 
-	virtual int64_t font_get_texture_count(const RID &p_font_rid, const Vector2i &p_size) const override;
-	virtual void font_clear_textures(const RID &p_font_rid, const Vector2i &p_size) override;
-	virtual void font_remove_texture(const RID &p_font_rid, const Vector2i &p_size, int64_t p_texture_index) override;
+	MODBIND4(font_set_texture_image, const RID &, const Vector2i &, int64_t, const Ref<Image> &);
+	MODBIND3RC(Ref<Image>, font_get_texture_image, const RID &, const Vector2i &, int64_t);
 
-	virtual void font_set_texture_image(const RID &p_font_rid, const Vector2i &p_size, int64_t p_texture_index, const Ref<Image> &p_image) override;
-	virtual Ref<Image> font_get_texture_image(const RID &p_font_rid, const Vector2i &p_size, int64_t p_texture_index) const override;
+	MODBIND4(font_set_texture_offsets, const RID &, const Vector2i &, int64_t, const PackedInt32Array &);
+	MODBIND3RC(PackedInt32Array, font_get_texture_offsets, const RID &, const Vector2i &, int64_t);
 
-	virtual void font_set_texture_offsets(const RID &p_font_rid, const Vector2i &p_size, int64_t p_texture_index, const PackedInt32Array &p_offset) override;
-	virtual PackedInt32Array font_get_texture_offsets(const RID &p_font_rid, const Vector2i &p_size, int64_t p_texture_index) const override;
+	MODBIND2RC(PackedInt32Array, font_get_glyph_list, const RID &, const Vector2i &);
+	MODBIND2(font_clear_glyphs, const RID &, const Vector2i &);
+	MODBIND3(font_remove_glyph, const RID &, const Vector2i &, int64_t);
 
-	virtual PackedInt32Array font_get_glyph_list(const RID &p_font_rid, const Vector2i &p_size) const override;
-	virtual void font_clear_glyphs(const RID &p_font_rid, const Vector2i &p_size) override;
-	virtual void font_remove_glyph(const RID &p_font_rid, const Vector2i &p_size, int64_t p_glyph) override;
+	MODBIND3RC(Vector2, font_get_glyph_advance, const RID &, int64_t, int64_t);
+	MODBIND4(font_set_glyph_advance, const RID &, int64_t, int64_t, const Vector2 &);
 
-	virtual Vector2 font_get_glyph_advance(const RID &p_font_rid, int64_t p_size, int64_t p_glyph) const override;
-	virtual void font_set_glyph_advance(const RID &p_font_rid, int64_t p_size, int64_t p_glyph, const Vector2 &p_advance) override;
+	MODBIND3RC(Vector2, font_get_glyph_offset, const RID &, const Vector2i &, int64_t);
+	MODBIND4(font_set_glyph_offset, const RID &, const Vector2i &, int64_t, const Vector2 &);
 
-	virtual Vector2 font_get_glyph_offset(const RID &p_font_rid, const Vector2i &p_size, int64_t p_glyph) const override;
-	virtual void font_set_glyph_offset(const RID &p_font_rid, const Vector2i &p_size, int64_t p_glyph, const Vector2 &p_offset) override;
+	MODBIND3RC(Vector2, font_get_glyph_size, const RID &, const Vector2i &, int64_t);
+	MODBIND4(font_set_glyph_size, const RID &, const Vector2i &, int64_t, const Vector2 &);
 
-	virtual Vector2 font_get_glyph_size(const RID &p_font_rid, const Vector2i &p_size, int64_t p_glyph) const override;
-	virtual void font_set_glyph_size(const RID &p_font_rid, const Vector2i &p_size, int64_t p_glyph, const Vector2 &p_gl_size) override;
+	MODBIND3RC(Rect2, font_get_glyph_uv_rect, const RID &, const Vector2i &, int64_t);
+	MODBIND4(font_set_glyph_uv_rect, const RID &, const Vector2i &, int64_t, const Rect2 &);
 
-	virtual Rect2 font_get_glyph_uv_rect(const RID &p_font_rid, const Vector2i &p_size, int64_t p_glyph) const override;
-	virtual void font_set_glyph_uv_rect(const RID &p_font_rid, const Vector2i &p_size, int64_t p_glyph, const Rect2 &p_uv_rect) override;
+	MODBIND3RC(int64_t, font_get_glyph_texture_idx, const RID &, const Vector2i &, int64_t);
+	MODBIND4(font_set_glyph_texture_idx, const RID &, const Vector2i &, int64_t, int64_t);
 
-	virtual int64_t font_get_glyph_texture_idx(const RID &p_font_rid, const Vector2i &p_size, int64_t p_glyph) const override;
-	virtual void font_set_glyph_texture_idx(const RID &p_font_rid, const Vector2i &p_size, int64_t p_glyph, int64_t p_texture_idx) override;
-	virtual RID font_get_glyph_texture_rid(const RID &p_font_rid, const Vector2i &p_size, int64_t p_glyph) const override;
-	virtual Size2 font_get_glyph_texture_size(const RID &p_font_rid, const Vector2i &p_size, int64_t p_glyph) const override;
+	MODBIND3RC(RID, font_get_glyph_texture_rid, const RID &, const Vector2i &, int64_t);
+	MODBIND3RC(Size2, font_get_glyph_texture_size, const RID &, const Vector2i &, int64_t);
 
-	virtual Dictionary font_get_glyph_contours(const RID &p_font, int64_t p_size, int64_t p_index) const override;
+	MODBIND3RC(Dictionary, font_get_glyph_contours, const RID &, int64_t, int64_t);
 
-	virtual TypedArray<Vector2i> font_get_kerning_list(const RID &p_font_rid, int64_t p_size) const override;
-	virtual void font_clear_kerning_map(const RID &p_font_rid, int64_t p_size) override;
-	virtual void font_remove_kerning(const RID &p_font_rid, int64_t p_size, const Vector2i &p_glyph_pair) override;
+	MODBIND2RC(TypedArray<Vector2i>, font_get_kerning_list, const RID &, int64_t);
+	MODBIND2(font_clear_kerning_map, const RID &, int64_t);
+	MODBIND3(font_remove_kerning, const RID &, int64_t, const Vector2i &);
 
-	virtual void font_set_kerning(const RID &p_font_rid, int64_t p_size, const Vector2i &p_glyph_pair, const Vector2 &p_kerning) override;
-	virtual Vector2 font_get_kerning(const RID &p_font_rid, int64_t p_size, const Vector2i &p_glyph_pair) const override;
+	MODBIND4(font_set_kerning, const RID &, int64_t, const Vector2i &, const Vector2 &);
+	MODBIND3RC(Vector2, font_get_kerning, const RID &, int64_t, const Vector2i &);
 
-	virtual int64_t font_get_glyph_index(const RID &p_font_rid, int64_t p_size, int64_t p_char, int64_t p_variation_selector = 0) const override;
+	MODBIND4RC(int64_t, font_get_glyph_index, const RID &, int64_t, int64_t, int64_t);
 
-	virtual bool font_has_char(const RID &p_font_rid, int64_t p_char) const override;
-	virtual String font_get_supported_chars(const RID &p_font_rid) const override;
+	MODBIND2RC(bool, font_has_char, const RID &, int64_t);
+	MODBIND1RC(String, font_get_supported_chars, const RID &);
 
-	virtual void font_render_range(const RID &p_font, const Vector2i &p_size, int64_t p_start, int64_t p_end) override;
-	virtual void font_render_glyph(const RID &p_font_rid, const Vector2i &p_size, int64_t p_index) override;
+	MODBIND4(font_render_range, const RID &, const Vector2i &, int64_t, int64_t);
+	MODBIND3(font_render_glyph, const RID &, const Vector2i &, int64_t);
 
-	virtual void font_draw_glyph(const RID &p_font, const RID &p_canvas, int64_t p_size, const Vector2 &p_pos, int64_t p_index, const Color &p_color = Color(1, 1, 1)) const override;
-	virtual void font_draw_glyph_outline(const RID &p_font, const RID &p_canvas, int64_t p_size, int64_t p_outline_size, const Vector2 &p_pos, int64_t p_index, const Color &p_color = Color(1, 1, 1)) const override;
+	MODBIND6C(font_draw_glyph, const RID &, const RID &, int64_t, const Vector2 &, int64_t, const Color &);
+	MODBIND7C(font_draw_glyph_outline, const RID &, const RID &, int64_t, int64_t, const Vector2 &, int64_t, const Color &);
 
-	virtual bool font_is_language_supported(const RID &p_font_rid, const String &p_language) const override;
-	virtual void font_set_language_support_override(const RID &p_font_rid, const String &p_language, bool p_supported) override;
-	virtual bool font_get_language_support_override(const RID &p_font_rid, const String &p_language) override;
-	virtual void font_remove_language_support_override(const RID &p_font_rid, const String &p_language) override;
-	virtual PackedStringArray font_get_language_support_overrides(const RID &p_font_rid) override;
+	MODBIND2RC(bool, font_is_language_supported, const RID &, const String &);
+	MODBIND3(font_set_language_support_override, const RID &, const String &, bool);
+	MODBIND2R(bool, font_get_language_support_override, const RID &, const String &);
+	MODBIND2(font_remove_language_support_override, const RID &, const String &);
+	MODBIND1R(PackedStringArray, font_get_language_support_overrides, const RID &);
 
-	virtual bool font_is_script_supported(const RID &p_font_rid, const String &p_script) const override;
-	virtual void font_set_script_support_override(const RID &p_font_rid, const String &p_script, bool p_supported) override;
-	virtual bool font_get_script_support_override(const RID &p_font_rid, const String &p_script) override;
-	virtual void font_remove_script_support_override(const RID &p_font_rid, const String &p_script) override;
-	virtual PackedStringArray font_get_script_support_overrides(const RID &p_font_rid) override;
+	MODBIND2RC(bool, font_is_script_supported, const RID &, const String &);
+	MODBIND3(font_set_script_support_override, const RID &, const String &, bool);
+	MODBIND2R(bool, font_get_script_support_override, const RID &, const String &);
+	MODBIND2(font_remove_script_support_override, const RID &, const String &);
+	MODBIND1R(PackedStringArray, font_get_script_support_overrides, const RID &);
 
-	virtual void font_set_opentype_feature_overrides(const RID &p_font_rid, const Dictionary &p_overrides) override;
-	virtual Dictionary font_get_opentype_feature_overrides(const RID &p_font_rid) const override;
+	MODBIND2(font_set_opentype_feature_overrides, const RID &, const Dictionary &);
+	MODBIND1RC(Dictionary, font_get_opentype_feature_overrides, const RID &);
 
-	virtual Dictionary font_supported_feature_list(const RID &p_font_rid) const override;
-	virtual Dictionary font_supported_variation_list(const RID &p_font_rid) const override;
+	MODBIND1RC(Dictionary, font_supported_feature_list, const RID &);
+	MODBIND1RC(Dictionary, font_supported_variation_list, const RID &);
 
-	virtual double font_get_global_oversampling() const override;
-	virtual void font_set_global_oversampling(double p_oversampling) override;
+	MODBIND0RC(double, font_get_global_oversampling);
+	MODBIND1(font_set_global_oversampling, double);
 
 	/* Shaped text buffer interface */
 
-	virtual RID create_shaped_text(Direction p_direction = DIRECTION_AUTO, Orientation p_orientation = ORIENTATION_HORIZONTAL) override;
+	MODBIND2R(RID, create_shaped_text, Direction, Orientation);
 
-	virtual void shaped_text_clear(const RID &p_shaped) override;
+	MODBIND1(shaped_text_clear, const RID &);
 
-	virtual void shaped_text_set_direction(const RID &p_shaped, Direction p_direction = DIRECTION_AUTO) override;
-	virtual Direction shaped_text_get_direction(const RID &p_shaped) const override;
-	virtual Direction shaped_text_get_inferred_direction(const RID &p_shaped) const override;
+	MODBIND2(shaped_text_set_direction, const RID &, Direction);
+	MODBIND1RC(Direction, shaped_text_get_direction, const RID &);
+	MODBIND1RC(Direction, shaped_text_get_inferred_direction, const RID &);
 
-	virtual void shaped_text_set_bidi_override(const RID &p_shaped, const Array &p_override) override;
+	MODBIND2(shaped_text_set_bidi_override, const RID &, const Array &);
 
-	virtual void shaped_text_set_custom_punctuation(const RID &p_shaped, const String &p_punct) override;
-	virtual String shaped_text_get_custom_punctuation(const RID &p_shaped) const override;
+	MODBIND2(shaped_text_set_custom_punctuation, const RID &, const String &);
+	MODBIND1RC(String, shaped_text_get_custom_punctuation, const RID &);
 
-	virtual void shaped_text_set_orientation(const RID &p_shaped, Orientation p_orientation = ORIENTATION_HORIZONTAL) override;
-	virtual Orientation shaped_text_get_orientation(const RID &p_shaped) const override;
+	MODBIND2(shaped_text_set_orientation, const RID &, Orientation);
+	MODBIND1RC(Orientation, shaped_text_get_orientation, const RID &);
 
-	virtual void shaped_text_set_preserve_invalid(const RID &p_shaped, bool p_enabled) override;
-	virtual bool shaped_text_get_preserve_invalid(const RID &p_shaped) const override;
+	MODBIND2(shaped_text_set_preserve_invalid, const RID &, bool);
+	MODBIND1RC(bool, shaped_text_get_preserve_invalid, const RID &);
 
-	virtual void shaped_text_set_preserve_control(const RID &p_shaped, bool p_enabled) override;
-	virtual bool shaped_text_get_preserve_control(const RID &p_shaped) const override;
+	MODBIND2(shaped_text_set_preserve_control, const RID &, bool);
+	MODBIND1RC(bool, shaped_text_get_preserve_control, const RID &);
 
-	virtual void shaped_text_set_spacing(const RID &p_shaped, SpacingType p_spacing, int64_t p_value) override;
-	virtual int64_t shaped_text_get_spacing(const RID &p_shaped, SpacingType p_spacing) const override;
+	MODBIND3(shaped_text_set_spacing, const RID &, SpacingType, int64_t);
+	MODBIND2RC(int64_t, shaped_text_get_spacing, const RID &, SpacingType);
 
-	virtual bool shaped_text_add_string(const RID &p_shaped, const String &p_text, const TypedArray<RID> &p_fonts, int64_t p_size, const Dictionary &p_opentype_features = Dictionary(), const String &p_language = "", const Variant &p_meta = Variant()) override;
-	virtual bool shaped_text_add_object(const RID &p_shaped, const Variant &p_key, const Size2 &p_size, InlineAlignment p_inline_align = INLINE_ALIGNMENT_CENTER, int64_t p_length = 1) override;
-	virtual bool shaped_text_resize_object(const RID &p_shaped, const Variant &p_key, const Size2 &p_size, InlineAlignment p_inline_align = INLINE_ALIGNMENT_CENTER) override;
+	MODBIND7R(bool, shaped_text_add_string, const RID &, const String &, const TypedArray<RID> &, int64_t, const Dictionary &, const String &, const Variant &);
+	MODBIND5R(bool, shaped_text_add_object, const RID &, const Variant &, const Size2 &, InlineAlignment, int64_t);
+	MODBIND4R(bool, shaped_text_resize_object, const RID &, const Variant &, const Size2 &, InlineAlignment);
 
-	virtual int64_t shaped_get_span_count(const RID &p_shaped) const override;
-	virtual Variant shaped_get_span_meta(const RID &p_shaped, int64_t p_index) const override;
-	virtual void shaped_set_span_update_font(const RID &p_shaped, int64_t p_index, const TypedArray<RID> &p_fonts, int64_t p_size, const Dictionary &p_opentype_features = Dictionary()) override;
+	MODBIND1RC(int64_t, shaped_get_span_count, const RID &);
+	MODBIND2RC(Variant, shaped_get_span_meta, const RID &, int64_t);
+	MODBIND5(shaped_set_span_update_font, const RID &, int64_t, const TypedArray<RID> &, int64_t, const Dictionary &);
 
-	virtual RID shaped_text_substr(const RID &p_shaped, int64_t p_start, int64_t p_length) const override;
-	virtual RID shaped_text_get_parent(const RID &p_shaped) const override;
+	MODBIND3RC(RID, shaped_text_substr, const RID &, int64_t, int64_t);
+	MODBIND1RC(RID, shaped_text_get_parent, const RID &);
 
-	virtual double shaped_text_fit_to_width(const RID &p_shaped, double p_width, BitField<TextServer::JustificationFlag> p_jst_flags = JUSTIFICATION_WORD_BOUND | JUSTIFICATION_KASHIDA) override;
-	virtual double shaped_text_tab_align(const RID &p_shaped, const PackedFloat32Array &p_tab_stops) override;
+	MODBIND3R(double, shaped_text_fit_to_width, const RID &, double, BitField<TextServer::JustificationFlag>);
+	MODBIND2R(double, shaped_text_tab_align, const RID &, const PackedFloat32Array &);
 
-	virtual bool shaped_text_shape(const RID &p_shaped) override;
-	virtual bool shaped_text_update_breaks(const RID &p_shaped) override;
-	virtual bool shaped_text_update_justification_ops(const RID &p_shaped) override;
+	MODBIND1R(bool, shaped_text_shape, const RID &);
+	MODBIND1R(bool, shaped_text_update_breaks, const RID &);
+	MODBIND1R(bool, shaped_text_update_justification_ops, const RID &);
 
-	virtual int64_t shaped_text_get_trim_pos(const RID &p_shaped) const override;
-	virtual int64_t shaped_text_get_ellipsis_pos(const RID &p_shaped) const override;
-	virtual const Glyph *shaped_text_get_ellipsis_glyphs(const RID &p_shaped) const override;
-	virtual int64_t shaped_text_get_ellipsis_glyph_count(const RID &p_shaped) const override;
+	MODBIND1RC(int64_t, shaped_text_get_trim_pos, const RID &);
+	MODBIND1RC(int64_t, shaped_text_get_ellipsis_pos, const RID &);
+	MODBIND1RC(const Glyph *, shaped_text_get_ellipsis_glyphs, const RID &);
+	MODBIND1RC(int64_t, shaped_text_get_ellipsis_glyph_count, const RID &);
 
-	virtual void shaped_text_overrun_trim_to_width(const RID &p_shaped, double p_width, BitField<TextServer::TextOverrunFlag> p_trim_flags) override;
+	MODBIND3(shaped_text_overrun_trim_to_width, const RID &, double, BitField<TextServer::TextOverrunFlag>);
 
-	virtual bool shaped_text_is_ready(const RID &p_shaped) const override;
+	MODBIND1RC(bool, shaped_text_is_ready, const RID &);
 
-	virtual const Glyph *shaped_text_get_glyphs(const RID &p_shaped) const override;
-	virtual const Glyph *shaped_text_sort_logical(const RID &p_shaped) override;
-	virtual int64_t shaped_text_get_glyph_count(const RID &p_shaped) const override;
+	MODBIND1RC(const Glyph *, shaped_text_get_glyphs, const RID &);
+	MODBIND1R(const Glyph *, shaped_text_sort_logical, const RID &);
+	MODBIND1RC(int64_t, shaped_text_get_glyph_count, const RID &);
 
-	virtual Vector2i shaped_text_get_range(const RID &p_shaped) const override;
+	MODBIND1RC(Vector2i, shaped_text_get_range, const RID &);
 
-	virtual Array shaped_text_get_objects(const RID &p_shaped) const override;
-	virtual Rect2 shaped_text_get_object_rect(const RID &p_shaped, const Variant &p_key) const override;
+	MODBIND1RC(Array, shaped_text_get_objects, const RID &);
+	MODBIND2RC(Rect2, shaped_text_get_object_rect, const RID &, const Variant &);
 
-	virtual Size2 shaped_text_get_size(const RID &p_shaped) const override;
-	virtual double shaped_text_get_ascent(const RID &p_shaped) const override;
-	virtual double shaped_text_get_descent(const RID &p_shaped) const override;
-	virtual double shaped_text_get_width(const RID &p_shaped) const override;
-	virtual double shaped_text_get_underline_position(const RID &p_shaped) const override;
-	virtual double shaped_text_get_underline_thickness(const RID &p_shaped) const override;
+	MODBIND1RC(Size2, shaped_text_get_size, const RID &);
+	MODBIND1RC(double, shaped_text_get_ascent, const RID &);
+	MODBIND1RC(double, shaped_text_get_descent, const RID &);
+	MODBIND1RC(double, shaped_text_get_width, const RID &);
+	MODBIND1RC(double, shaped_text_get_underline_position, const RID &);
+	MODBIND1RC(double, shaped_text_get_underline_thickness, const RID &);
 
-	virtual PackedInt32Array string_get_word_breaks(const String &p_string, const String &p_language = "") const override;
+	MODBIND2RC(PackedInt32Array, string_get_word_breaks, const String &, const String &);
 
-	virtual String string_to_upper(const String &p_string, const String &p_language = "") const override;
-	virtual String string_to_lower(const String &p_string, const String &p_language = "") const override;
+	MODBIND2RC(String, string_to_upper, const String &, const String &);
+	MODBIND2RC(String, string_to_lower, const String &, const String &);
 
 	TextServerFallback();
 	~TextServerFallback();
-- 
cgit v1.2.3