Unify TextServer built-in module and GDExtension code.

10 files changed, 1793 insertions, 792 deletions

diff --git a/modules/text_server_adv/.gitignore b/modules/text_server_adv/.gitignore
new file mode 100644
index 0000000000..15cc38b59c
--- /dev/null
+++ b/modules/text_server_adv/.gitignore
@@ -0,0 +1,2 @@
+# Godot-cpp headers
+gdextension_build/godot-cpp
diff --git a/modules/text_server_adv/SCsub b/modules/text_server_adv/SCsub
index 5e5c284b57..50f7bd81a6 100644
--- a/modules/text_server_adv/SCsub
+++ b/modules/text_server_adv/SCsub
@@ -455,6 +455,7 @@ if env["builtin_icu"]:
     if env_icu["tools"]:
         env_icu.Depends("#thirdparty/icu4c/icudata.gen.h", "#thirdparty/icu4c/" + icu_data_name)
         env_icu.Command("#thirdparty/icu4c/icudata.gen.h", "#thirdparty/icu4c/" + icu_data_name, make_icu_data)
+        env_text_server_adv.Append(CPPPATH=["#thirdparty/icu4c/"])
     else:
         thirdparty_sources += ["icu_data/icudata_stub.cpp"]
 
diff --git a/modules/text_server_adv/doc_classes/TextServerAdvanced.xml b/modules/text_server_adv/doc_classes/TextServerAdvanced.xml
index bf86eb6406..91dde65cb8 100644
--- a/modules/text_server_adv/doc_classes/TextServerAdvanced.xml
+++ b/modules/text_server_adv/doc_classes/TextServerAdvanced.xml
@@ -1,5 +1,5 @@
 <?xml version="1.0" encoding="UTF-8" ?>
-<class name="TextServerAdvanced" inherits="TextServer" version="4.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="../../../doc/class.xsd">
+<class name="TextServerAdvanced" inherits="TextServerExtension" version="4.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="../../../doc/class.xsd">
 	<brief_description>
 		Text Server using HarfBuzz, ICU and SIL Graphite to support BiDi, complex text layouts and contextual OpenType features.
 	</brief_description>
diff --git a/modules/text_server_adv/gdextension_build/SConstruct b/modules/text_server_adv/gdextension_build/SConstruct
new file mode 100644
index 0000000000..b294fab561
--- /dev/null
+++ b/modules/text_server_adv/gdextension_build/SConstruct
@@ -0,0 +1,638 @@
+#!/usr/bin/env python
+import atexit
+import os
+import sys
+import methods
+import time
+
+# For the reference:
+# - CCFLAGS are compilation flags shared between C and C++
+# - CFLAGS are for C-specific compilation flags
+# - CXXFLAGS are for C++-specific compilation flags
+# - CPPFLAGS are for pre-processor flags
+# - CPPDEFINES are for pre-processor defines
+# - LINKFLAGS are for linking flags
+
+time_at_start = time.time()
+
+env = SConscript("./godot-cpp/SConstruct")
+env.__class__.disable_warnings = methods.disable_warnings
+
+opts = Variables([], ARGUMENTS)
+opts.Add(BoolVariable("freetype_enabled", "Use FreeType library", True))
+opts.Add(BoolVariable("msdfgen_enabled", "Use MSDFgen library (require FreeType)", True))
+opts.Add(BoolVariable("graphite_enabled", "Use Graphite library (require FreeType)", True))
+opts.Add(BoolVariable("static_icu_data", "Use built-in ICU data", True))
+opts.Add(BoolVariable("verbose", "Enable verbose output for the compilation", False))
+
+opts.Update(env)
+
+if not env["verbose"]:
+    methods.no_verbose(sys, env)
+
+if env["platform"] == "windows" and not env["use_mingw"]:
+    env.AppendUnique(CCFLAGS=["/utf-8"])  # Force to use Unicode encoding.
+
+# MSDFGEN
+if env["msdfgen_enabled"] and env["freetype_enabled"]:
+    env_msdfgen = env.Clone()
+    env_msdfgen.disable_warnings()
+
+    thirdparty_msdfgen_dir = "../../../thirdparty/msdfgen/"
+    thirdparty_msdfgen_sources = [
+        "core/Contour.cpp",
+        "core/EdgeHolder.cpp",
+        "core/MSDFErrorCorrection.cpp",
+        "core/Projection.cpp",
+        "core/Scanline.cpp",
+        "core/Shape.cpp",
+        "core/SignedDistance.cpp",
+        "core/Vector2.cpp",
+        "core/contour-combiners.cpp",
+        "core/edge-coloring.cpp",
+        "core/edge-segments.cpp",
+        "core/edge-selectors.cpp",
+        "core/equation-solver.cpp",
+        "core/msdf-error-correction.cpp",
+        "core/msdfgen.cpp",
+        "core/rasterization.cpp",
+        "core/render-sdf.cpp",
+        "core/sdf-error-estimation.cpp",
+        "core/shape-description.cpp",
+    ]
+    thirdparty_msdfgen_sources = [thirdparty_msdfgen_dir + file for file in thirdparty_msdfgen_sources]
+
+    env_msdfgen.Append(CPPPATH=["../../../thirdparty/freetype/include", "../../../thirdparty/msdfgen"])
+    env.Append(CPPPATH=["../../../thirdparty/msdfgen"])
+    env.Append(CPPDEFINES=["MODULE_MSDFGEN_ENABLED"])
+
+    lib = env_msdfgen.Library(
+        f'msdfgen_builtin.{env["platform"]}.{env["target"]}.{env["arch_suffix"]}{env["LIBSUFFIX"]}',
+        thirdparty_msdfgen_sources,
+    )
+    env.Append(LIBS=[lib])
+
+# FreeType
+if env["freetype_enabled"]:
+    env_freetype = env.Clone()
+    env_freetype.disable_warnings()
+
+    thirdparty_freetype_dir = "../../../thirdparty/freetype/"
+    thirdparty_freetype_sources = [
+        "src/autofit/autofit.c",
+        "src/base/ftbase.c",
+        "src/base/ftbbox.c",
+        "src/base/ftbdf.c",
+        "src/base/ftbitmap.c",
+        "src/base/ftcid.c",
+        "src/base/ftdebug.c",
+        "src/base/ftfstype.c",
+        "src/base/ftgasp.c",
+        "src/base/ftglyph.c",
+        "src/base/ftgxval.c",
+        "src/base/ftinit.c",
+        "src/base/ftmm.c",
+        "src/base/ftotval.c",
+        "src/base/ftpatent.c",
+        "src/base/ftpfr.c",
+        "src/base/ftstroke.c",
+        "src/base/ftsynth.c",
+        "src/base/ftsystem.c",
+        "src/base/fttype1.c",
+        "src/base/ftwinfnt.c",
+        "src/bdf/bdf.c",
+        "src/bzip2/ftbzip2.c",
+        "src/cache/ftcache.c",
+        "src/cff/cff.c",
+        "src/cid/type1cid.c",
+        "src/gxvalid/gxvalid.c",
+        "src/gzip/ftgzip.c",
+        "src/lzw/ftlzw.c",
+        "src/otvalid/otvalid.c",
+        "src/pcf/pcf.c",
+        "src/pfr/pfr.c",
+        "src/psaux/psaux.c",
+        "src/pshinter/pshinter.c",
+        "src/psnames/psnames.c",
+        "src/raster/raster.c",
+        "src/sdf/sdf.c",
+        "src/smooth/smooth.c",
+        "src/truetype/truetype.c",
+        "src/type1/type1.c",
+        "src/type42/type42.c",
+        "src/winfonts/winfnt.c",
+        "src/sfnt/sfnt.c",
+    ]
+    thirdparty_freetype_sources = [thirdparty_freetype_dir + file for file in thirdparty_freetype_sources]
+
+    thirdparty_png_dir = "../../../thirdparty/libpng/"
+    thirdparty_png_sources = [
+        "png.c",
+        "pngerror.c",
+        "pngget.c",
+        "pngmem.c",
+        "pngpread.c",
+        "pngread.c",
+        "pngrio.c",
+        "pngrtran.c",
+        "pngrutil.c",
+        "pngset.c",
+        "pngtrans.c",
+        "pngwio.c",
+        "pngwrite.c",
+        "pngwtran.c",
+        "pngwutil.c",
+    ]
+    thirdparty_freetype_sources += [thirdparty_png_dir + file for file in thirdparty_png_sources]
+
+    thirdparty_zlib_dir = "../../../thirdparty/zlib/"
+    thirdparty_zlib_sources = [
+        "adler32.c",
+        "compress.c",
+        "crc32.c",
+        "deflate.c",
+        "infback.c",
+        "inffast.c",
+        "inflate.c",
+        "inftrees.c",
+        "trees.c",
+        "uncompr.c",
+        "zutil.c",
+    ]
+    thirdparty_freetype_sources += [thirdparty_zlib_dir + file for file in thirdparty_zlib_sources]
+
+    env_freetype.Append(CPPPATH=[thirdparty_freetype_dir + "/include", thirdparty_zlib_dir, thirdparty_png_dir])
+    env.Append(CPPPATH=[thirdparty_freetype_dir + "/include"])
+
+    env_freetype.Append(CPPDEFINES=["FT2_BUILD_LIBRARY", "FT_CONFIG_OPTION_USE_PNG", ("PNG_ARM_NEON_OPT", 0)])
+    if env["target"] == "debug":
+        env_freetype.Append(CPPDEFINES=["ZLIB_DEBUG"])
+
+    env.Append(CPPDEFINES=["MODULE_FREETYPE_ENABLED"])
+
+    lib = env_freetype.Library(
+        f'freetype_builtin.{env["platform"]}.{env["target"]}.{env["arch_suffix"]}{env["LIBSUFFIX"]}',
+        thirdparty_freetype_sources,
+    )
+    env.Append(LIBS=[lib])
+
+# HarfBuzz
+env_harfbuzz = env.Clone()
+env_harfbuzz.disable_warnings()
+
+thirdparty_harfbuzz_dir = "../../../thirdparty/harfbuzz/"
+thirdparty_harfbuzz_sources = [
+    "src/hb-aat-layout.cc",
+    "src/hb-aat-map.cc",
+    "src/hb-blob.cc",
+    "src/hb-buffer-serialize.cc",
+    "src/hb-buffer-verify.cc",
+    "src/hb-buffer.cc",
+    "src/hb-common.cc",
+    #'src/hb-coretext.cc',
+    #'src/hb-directwrite.cc',
+    "src/hb-draw.cc",
+    "src/hb-face.cc",
+    "src/hb-fallback-shape.cc",
+    "src/hb-font.cc",
+    #'src/hb-gdi.cc',
+    #'src/hb-glib.cc',
+    #'src/hb-gobject-structs.cc',
+    "src/hb-icu.cc",
+    "src/hb-map.cc",
+    "src/hb-number.cc",
+    "src/hb-ot-cff1-table.cc",
+    "src/hb-ot-cff2-table.cc",
+    "src/hb-ot-color.cc",
+    "src/hb-ot-face.cc",
+    "src/hb-ot-font.cc",
+    "src/hb-ot-layout.cc",
+    "src/hb-ot-map.cc",
+    "src/hb-ot-math.cc",
+    "src/hb-ot-meta.cc",
+    "src/hb-ot-metrics.cc",
+    "src/hb-ot-name.cc",
+    "src/hb-ot-shape-complex-arabic.cc",
+    "src/hb-ot-shape-complex-default.cc",
+    "src/hb-ot-shape-complex-hangul.cc",
+    "src/hb-ot-shape-complex-hebrew.cc",
+    "src/hb-ot-shape-complex-indic-table.cc",
+    "src/hb-ot-shape-complex-indic.cc",
+    "src/hb-ot-shape-complex-khmer.cc",
+    "src/hb-ot-shape-complex-myanmar.cc",
+    "src/hb-ot-shape-complex-syllabic.cc",
+    "src/hb-ot-shape-complex-thai.cc",
+    "src/hb-ot-shape-complex-use.cc",
+    "src/hb-ot-shape-complex-vowel-constraints.cc",
+    "src/hb-ot-shape-fallback.cc",
+    "src/hb-ot-shape-normalize.cc",
+    "src/hb-ot-shape.cc",
+    "src/hb-ot-tag.cc",
+    "src/hb-ot-var.cc",
+    "src/hb-set.cc",
+    "src/hb-shape-plan.cc",
+    "src/hb-shape.cc",
+    "src/hb-shaper.cc",
+    "src/hb-static.cc",
+    "src/hb-style.cc",
+    "src/hb-subset-cff-common.cc",
+    "src/hb-subset-cff1.cc",
+    "src/hb-subset-cff2.cc",
+    "src/hb-subset-input.cc",
+    "src/hb-subset-plan.cc",
+    "src/hb-subset.cc",
+    "src/hb-ucd.cc",
+    "src/hb-unicode.cc",
+    #'src/hb-uniscribe.cc'
+]
+
+if env["freetype_enabled"]:
+    thirdparty_harfbuzz_sources += [
+        "src/hb-ft.cc",
+        "src/hb-graphite2.cc",
+    ]
+thirdparty_harfbuzz_sources = [thirdparty_harfbuzz_dir + file for file in thirdparty_harfbuzz_sources]
+
+env_harfbuzz.Append(
+    CPPPATH=[
+        "../../../thirdparty/harfbuzz/src",
+        "../../../thirdparty/icu4c/common/",
+    ]
+)
+
+if env["freetype_enabled"]:
+    env_harfbuzz.Append(
+        CPPPATH=[
+            "../../../thirdparty/freetype/include",
+            "../../../thirdparty/graphite/include",
+        ]
+    )
+
+if env["platform"] == "android" or env["platform"] == "linuxbsd":
+    env_harfbuzz.Append(CCFLAGS=["-DHAVE_PTHREAD"])
+
+env_harfbuzz.Append(
+    CCFLAGS=[
+        "-DHAVE_ICU_BUILTIN",
+        "-DHAVE_ICU",
+    ]
+)
+
+if env["freetype_enabled"]:
+    env_harfbuzz.Append(
+        CCFLAGS=[
+            "-DHAVE_FREETYPE",
+            "-DHAVE_GRAPHITE2",
+            "-DGRAPHITE2_STATIC",
+        ]
+    )
+
+env.Append(CPPPATH=["../../../thirdparty/harfbuzz/src"])
+
+lib = env_harfbuzz.Library(
+    f'harfbuzz_builtin.{env["platform"]}.{env["target"]}.{env["arch_suffix"]}{env["LIBSUFFIX"]}',
+    thirdparty_harfbuzz_sources,
+)
+env.Prepend(LIBS=[lib])
+
+# Graphite
+if env["graphite_enabled"] and env["freetype_enabled"]:
+    env_graphite = env.Clone()
+    env_graphite.disable_warnings()
+
+    thirdparty_graphite_dir = "../../../thirdparty/graphite/"
+    thirdparty_graphite_sources = [
+        "src/gr_char_info.cpp",
+        "src/gr_face.cpp",
+        "src/gr_features.cpp",
+        "src/gr_font.cpp",
+        "src/gr_logging.cpp",
+        "src/gr_segment.cpp",
+        "src/gr_slot.cpp",
+        "src/CmapCache.cpp",
+        "src/Code.cpp",
+        "src/Collider.cpp",
+        "src/Decompressor.cpp",
+        "src/Face.cpp",
+        #'src/FileFace.cpp',
+        "src/FeatureMap.cpp",
+        "src/Font.cpp",
+        "src/GlyphCache.cpp",
+        "src/GlyphFace.cpp",
+        "src/Intervals.cpp",
+        "src/Justifier.cpp",
+        "src/NameTable.cpp",
+        "src/Pass.cpp",
+        "src/Position.cpp",
+        "src/Segment.cpp",
+        "src/Silf.cpp",
+        "src/Slot.cpp",
+        "src/Sparse.cpp",
+        "src/TtfUtil.cpp",
+        "src/UtfCodec.cpp",
+        "src/FileFace.cpp",
+        "src/json.cpp",
+    ]
+    if env["platform"] != "windows" or env["use_mingw"]:
+        thirdparty_graphite_sources += ["src/direct_machine.cpp"]
+    else:
+        thirdparty_graphite_sources += ["src/call_machine.cpp"]
+
+    thirdparty_graphite_sources = [thirdparty_graphite_dir + file for file in thirdparty_graphite_sources]
+
+    env_graphite.Append(CPPPATH=["../../../thirdparty/graphite/src", "../../../thirdparty/graphite/include"])
+    env_graphite.Append(
+        CCFLAGS=[
+            "-DGRAPHITE2_STATIC",
+            "-DGRAPHITE2_NTRACING",
+            "-DGRAPHITE2_NFILEFACE",
+        ]
+    )
+
+    lib = env_graphite.Library(
+        f'graphite_builtin.{env["platform"]}.{env["target"]}.{env["arch_suffix"]}{env["LIBSUFFIX"]}',
+        thirdparty_graphite_sources,
+    )
+    env.Append(LIBS=[lib])
+
+# ICU
+env_icu = env.Clone()
+env_icu.disable_warnings()
+
+thirdparty_icu_dir = "../../../thirdparty/icu4c/"
+thirdparty_icu_sources = [
+    "common/appendable.cpp",
+    "common/bmpset.cpp",
+    "common/brkeng.cpp",
+    "common/brkiter.cpp",
+    "common/bytesinkutil.cpp",
+    "common/bytestream.cpp",
+    "common/bytestrie.cpp",
+    "common/bytestriebuilder.cpp",
+    "common/bytestrieiterator.cpp",
+    "common/caniter.cpp",
+    "common/characterproperties.cpp",
+    "common/chariter.cpp",
+    "common/charstr.cpp",
+    "common/cmemory.cpp",
+    "common/cstr.cpp",
+    "common/cstring.cpp",
+    "common/cwchar.cpp",
+    "common/dictbe.cpp",
+    "common/dictionarydata.cpp",
+    "common/dtintrv.cpp",
+    "common/edits.cpp",
+    "common/emojiprops.cpp",
+    "common/errorcode.cpp",
+    "common/filteredbrk.cpp",
+    "common/filterednormalizer2.cpp",
+    "common/icudataver.cpp",
+    "common/icuplug.cpp",
+    "common/loadednormalizer2impl.cpp",
+    "common/localebuilder.cpp",
+    "common/localematcher.cpp",
+    "common/localeprioritylist.cpp",
+    "common/locavailable.cpp",
+    "common/locbased.cpp",
+    "common/locdispnames.cpp",
+    "common/locdistance.cpp",
+    "common/locdspnm.cpp",
+    "common/locid.cpp",
+    "common/loclikely.cpp",
+    "common/loclikelysubtags.cpp",
+    "common/locmap.cpp",
+    "common/locresdata.cpp",
+    "common/locutil.cpp",
+    "common/lsr.cpp",
+    "common/lstmbe.cpp",
+    "common/messagepattern.cpp",
+    "common/normalizer2.cpp",
+    "common/normalizer2impl.cpp",
+    "common/normlzr.cpp",
+    "common/parsepos.cpp",
+    "common/patternprops.cpp",
+    "common/pluralmap.cpp",
+    "common/propname.cpp",
+    "common/propsvec.cpp",
+    "common/punycode.cpp",
+    "common/putil.cpp",
+    "common/rbbi.cpp",
+    "common/rbbi_cache.cpp",
+    "common/rbbidata.cpp",
+    "common/rbbinode.cpp",
+    "common/rbbirb.cpp",
+    "common/rbbiscan.cpp",
+    "common/rbbisetb.cpp",
+    "common/rbbistbl.cpp",
+    "common/rbbitblb.cpp",
+    "common/resbund.cpp",
+    "common/resbund_cnv.cpp",
+    "common/resource.cpp",
+    "common/restrace.cpp",
+    "common/ruleiter.cpp",
+    "common/schriter.cpp",
+    "common/serv.cpp",
+    "common/servlk.cpp",
+    "common/servlkf.cpp",
+    "common/servls.cpp",
+    "common/servnotf.cpp",
+    "common/servrbf.cpp",
+    "common/servslkf.cpp",
+    "common/sharedobject.cpp",
+    "common/simpleformatter.cpp",
+    "common/static_unicode_sets.cpp",
+    "common/stringpiece.cpp",
+    "common/stringtriebuilder.cpp",
+    "common/uarrsort.cpp",
+    "common/ubidi.cpp",
+    "common/ubidi_props.cpp",
+    "common/ubidiln.cpp",
+    "common/ubiditransform.cpp",
+    "common/ubidiwrt.cpp",
+    "common/ubrk.cpp",
+    "common/ucase.cpp",
+    "common/ucasemap.cpp",
+    "common/ucasemap_titlecase_brkiter.cpp",
+    "common/ucat.cpp",
+    "common/uchar.cpp",
+    "common/ucharstrie.cpp",
+    "common/ucharstriebuilder.cpp",
+    "common/ucharstrieiterator.cpp",
+    "common/uchriter.cpp",
+    "common/ucln_cmn.cpp",
+    "common/ucmndata.cpp",
+    "common/ucnv.cpp",
+    "common/ucnv2022.cpp",
+    "common/ucnv_bld.cpp",
+    "common/ucnv_cb.cpp",
+    "common/ucnv_cnv.cpp",
+    "common/ucnv_ct.cpp",
+    "common/ucnv_err.cpp",
+    "common/ucnv_ext.cpp",
+    "common/ucnv_io.cpp",
+    "common/ucnv_lmb.cpp",
+    "common/ucnv_set.cpp",
+    "common/ucnv_u16.cpp",
+    "common/ucnv_u32.cpp",
+    "common/ucnv_u7.cpp",
+    "common/ucnv_u8.cpp",
+    "common/ucnvbocu.cpp",
+    "common/ucnvdisp.cpp",
+    "common/ucnvhz.cpp",
+    "common/ucnvisci.cpp",
+    "common/ucnvlat1.cpp",
+    "common/ucnvmbcs.cpp",
+    "common/ucnvscsu.cpp",
+    "common/ucnvsel.cpp",
+    "common/ucol_swp.cpp",
+    "common/ucptrie.cpp",
+    "common/ucurr.cpp",
+    "common/udata.cpp",
+    "common/udatamem.cpp",
+    "common/udataswp.cpp",
+    "common/uenum.cpp",
+    "common/uhash.cpp",
+    "common/uhash_us.cpp",
+    "common/uidna.cpp",
+    "common/uinit.cpp",
+    "common/uinvchar.cpp",
+    "common/uiter.cpp",
+    "common/ulist.cpp",
+    "common/uloc.cpp",
+    "common/uloc_keytype.cpp",
+    "common/uloc_tag.cpp",
+    "common/umapfile.cpp",
+    "common/umath.cpp",
+    "common/umutablecptrie.cpp",
+    "common/umutex.cpp",
+    "common/unames.cpp",
+    "common/unifiedcache.cpp",
+    "common/unifilt.cpp",
+    "common/unifunct.cpp",
+    "common/uniset.cpp",
+    "common/uniset_closure.cpp",
+    "common/uniset_props.cpp",
+    "common/unisetspan.cpp",
+    "common/unistr.cpp",
+    "common/unistr_case.cpp",
+    "common/unistr_case_locale.cpp",
+    "common/unistr_cnv.cpp",
+    "common/unistr_props.cpp",
+    "common/unistr_titlecase_brkiter.cpp",
+    "common/unorm.cpp",
+    "common/unormcmp.cpp",
+    "common/uobject.cpp",
+    "common/uprops.cpp",
+    "common/ures_cnv.cpp",
+    "common/uresbund.cpp",
+    "common/uresdata.cpp",
+    "common/usc_impl.cpp",
+    "common/uscript.cpp",
+    "common/uscript_props.cpp",
+    "common/uset.cpp",
+    "common/uset_props.cpp",
+    "common/usetiter.cpp",
+    # "common/ushape.cpp",
+    "common/usprep.cpp",
+    "common/ustack.cpp",
+    "common/ustr_cnv.cpp",
+    "common/ustr_titlecase_brkiter.cpp",
+    "common/ustr_wcs.cpp",
+    "common/ustrcase.cpp",
+    "common/ustrcase_locale.cpp",
+    "common/ustrenum.cpp",
+    "common/ustrfmt.cpp",
+    "common/ustring.cpp",
+    "common/ustrtrns.cpp",
+    "common/utext.cpp",
+    "common/utf_impl.cpp",
+    "common/util.cpp",
+    "common/util_props.cpp",
+    "common/utrace.cpp",
+    "common/utrie.cpp",
+    "common/utrie2.cpp",
+    "common/utrie2_builder.cpp",
+    "common/utrie_swap.cpp",
+    "common/uts46.cpp",
+    "common/utypes.cpp",
+    "common/uvector.cpp",
+    "common/uvectr32.cpp",
+    "common/uvectr64.cpp",
+    "common/wintz.cpp",
+]
+thirdparty_icu_sources = [thirdparty_icu_dir + file for file in thirdparty_icu_sources]
+
+icu_data_name = "icudt70l.dat"
+
+if env["static_icu_data"]:
+    env_icu.Depends("../../../thirdparty/icu4c/icudata.gen.h", "../../../thirdparty/icu4c/" + icu_data_name)
+    env_icu.Command(
+        "../../../thirdparty/icu4c/icudata.gen.h", "../../../thirdparty/icu4c/" + icu_data_name, methods.make_icu_data
+    )
+    env.Append(CXXFLAGS=["-DICU_STATIC_DATA"])
+    env.Append(CPPPATH=["../../../thirdparty/icu4c/"])
+else:
+    thirdparty_sources += ["../icu_data/icudata_stub.cpp"]
+
+env_icu.Append(CPPPATH=["../../../thirdparty/icu4c/common/"])
+env_icu.Append(
+    CXXFLAGS=[
+        "-DU_STATIC_IMPLEMENTATION",
+        "-DU_COMMON_IMPLEMENTATION",
+        "-DUCONFIG_NO_COLLATION",
+        "-DUCONFIG_NO_CONVERSION",
+        "-DUCONFIG_NO_FORMATTING",
+        "-DUCONFIG_NO_SERVICE",
+        "-DUCONFIG_NO_IDNA",
+        "-DUCONFIG_NO_FILE_IO",
+        "-DUCONFIG_NO_TRANSLITERATION",
+        "-DPKGDATA_MODE=static",
+        "-DICU_DATA_NAME=" + icu_data_name,
+    ]
+)
+env.Append(
+    CXXFLAGS=[
+        "-DICU_DATA_NAME=" + icu_data_name,
+    ]
+)
+env.Append(CPPPATH=["../../../thirdparty/icu4c/common/"])
+
+if env["platform"] == "windows":
+    env.Append(LIBS=["advapi32"])
+
+lib = env_icu.Library(
+    f'icu_builtin.{env["platform"]}.{env["target"]}.{env["arch_suffix"]}{env["LIBSUFFIX"]}', thirdparty_icu_sources
+)
+env.Append(LIBS=[lib])
+
+env.Append(CPPDEFINES=["GDEXTENSION"])
+env.Append(CPPPATH=["../"])
+sources = Glob("../*.cpp")
+
+if env["platform"] == "osx":
+    methods.write_osx_plist(
+        f'./bin/libtextserver_advanced.osx.{env["target"]}.framework',
+        f'libtextserver_advanced.osx.{env["target"]}',
+        "org.godotengine.textserver_advanced",
+        "ICU / HarfBuzz / Graphite Text Server",
+    )
+    library = env.SharedLibrary(
+        f'./bin/libtextserver_advanced.osx.{env["target"]}.framework/libtextserver_advanced.osx.{env["target"]}',
+        source=sources,
+    )
+else:
+    library = env.SharedLibrary(
+        f'./bin/libtextserver_advanced.{env["platform"]}.{env["target"]}.{env["arch_suffix"]}{env["SHLIBSUFFIX"]}',
+        source=sources,
+    )
+
+Default(library)
+
+
+def print_elapsed_time():
+    elapsed_time_sec = round(time.time() - time_at_start, 3)
+    time_ms = round((elapsed_time_sec % 1) * 1000)
+    print("[Time elapsed: {}.{:03}]".format(time.strftime("%H:%M:%S", time.gmtime(elapsed_time_sec)), time_ms))
+
+
+atexit.register(print_elapsed_time)
diff --git a/modules/text_server_adv/gdextension_build/methods.py b/modules/text_server_adv/gdextension_build/methods.py
new file mode 100644
index 0000000000..d404f2851e
--- /dev/null
+++ b/modules/text_server_adv/gdextension_build/methods.py
@@ -0,0 +1,130 @@
+import os
+import sys
+
+
+def no_verbose(sys, env):
+    colors = {}
+
+    # Colors are disabled in non-TTY environments such as pipes. This means
+    # that if output is redirected to a file, it will not contain color codes
+    if sys.stdout.isatty():
+        colors["blue"] = "\033[0;94m"
+        colors["bold_blue"] = "\033[1;94m"
+        colors["reset"] = "\033[0m"
+    else:
+        colors["blue"] = ""
+        colors["bold_blue"] = ""
+        colors["reset"] = ""
+
+    # There is a space before "..." to ensure that source file names can be
+    # Ctrl + clicked in the VS Code terminal.
+    compile_source_message = "{}Compiling {}$SOURCE{} ...{}".format(
+        colors["blue"], colors["bold_blue"], colors["blue"], colors["reset"]
+    )
+    java_compile_source_message = "{}Compiling {}$SOURCE{} ...{}".format(
+        colors["blue"], colors["bold_blue"], colors["blue"], colors["reset"]
+    )
+    compile_shared_source_message = "{}Compiling shared {}$SOURCE{} ...{}".format(
+        colors["blue"], colors["bold_blue"], colors["blue"], colors["reset"]
+    )
+    link_program_message = "{}Linking Program {}$TARGET{} ...{}".format(
+        colors["blue"], colors["bold_blue"], colors["blue"], colors["reset"]
+    )
+    link_library_message = "{}Linking Static Library {}$TARGET{} ...{}".format(
+        colors["blue"], colors["bold_blue"], colors["blue"], colors["reset"]
+    )
+    ranlib_library_message = "{}Ranlib Library {}$TARGET{} ...{}".format(
+        colors["blue"], colors["bold_blue"], colors["blue"], colors["reset"]
+    )
+    link_shared_library_message = "{}Linking Shared Library {}$TARGET{} ...{}".format(
+        colors["blue"], colors["bold_blue"], colors["blue"], colors["reset"]
+    )
+    java_library_message = "{}Creating Java Archive {}$TARGET{} ...{}".format(
+        colors["blue"], colors["bold_blue"], colors["blue"], colors["reset"]
+    )
+
+    env.Append(CXXCOMSTR=[compile_source_message])
+    env.Append(CCCOMSTR=[compile_source_message])
+    env.Append(SHCCCOMSTR=[compile_shared_source_message])
+    env.Append(SHCXXCOMSTR=[compile_shared_source_message])
+    env.Append(ARCOMSTR=[link_library_message])
+    env.Append(RANLIBCOMSTR=[ranlib_library_message])
+    env.Append(SHLINKCOMSTR=[link_shared_library_message])
+    env.Append(LINKCOMSTR=[link_program_message])
+    env.Append(JARCOMSTR=[java_library_message])
+    env.Append(JAVACCOMSTR=[java_compile_source_message])
+
+
+def disable_warnings(self):
+    # 'self' is the environment
+    if self["platform"] == "windows" and not self["use_mingw"]:
+        # We have to remove existing warning level defines before appending /w,
+        # otherwise we get: "warning D9025 : overriding '/W3' with '/w'"
+        warn_flags = ["/Wall", "/W4", "/W3", "/W2", "/W1", "/WX"]
+        self.Append(CCFLAGS=["/w"])
+        self.Append(CFLAGS=["/w"])
+        self.Append(CXXFLAGS=["/w"])
+        self["CCFLAGS"] = [x for x in self["CCFLAGS"] if not x in warn_flags]
+        self["CFLAGS"] = [x for x in self["CFLAGS"] if not x in warn_flags]
+        self["CXXFLAGS"] = [x for x in self["CXXFLAGS"] if not x in warn_flags]
+    else:
+        self.Append(CCFLAGS=["-w"])
+        self.Append(CFLAGS=["-w"])
+        self.Append(CXXFLAGS=["-w"])
+
+
+def make_icu_data(target, source, env):
+    dst = target[0].srcnode().abspath
+    g = open(dst, "w", encoding="utf-8")
+
+    g.write("/* THIS FILE IS GENERATED DO NOT EDIT */\n")
+    g.write("/* (C) 2016 and later: Unicode, Inc. and others. */\n")
+    g.write("/* License & terms of use: https://www.unicode.org/copyright.html */\n")
+    g.write("#ifndef _ICU_DATA_H\n")
+    g.write("#define _ICU_DATA_H\n")
+    g.write('#include "unicode/utypes.h"\n')
+    g.write('#include "unicode/udata.h"\n')
+    g.write('#include "unicode/uversion.h"\n')
+
+    f = open(source[0].srcnode().abspath, "rb")
+    buf = f.read()
+
+    g.write('extern "C" U_EXPORT const size_t U_ICUDATA_SIZE = ' + str(len(buf)) + ";\n")
+    g.write('extern "C" U_EXPORT const unsigned char U_ICUDATA_ENTRY_POINT[] = {\n')
+    for i in range(len(buf)):
+        g.write("\t" + str(buf[i]) + ",\n")
+
+    g.write("};\n")
+    g.write("#endif")
+
+
+def write_osx_plist(target, binary_name, identifier, name):
+    os.makedirs(f"{target}/Resourece/", exist_ok=True)
+    f = open(f"{target}/Resourece/Info.plist", "w")
+
+    f.write(f'<?xml version="1.0" encoding="UTF-8"?>\n')
+    f.write(f'<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">\n')
+    f.write(f'<plist version="1.0">\n')
+    f.write(f"<dict>\n")
+    f.write(f"\t<key>CFBundleExecutable</key>\n")
+    f.write(f"\t<string>{binary_name}</string>\n")
+    f.write(f"\t<key>CFBundleIdentifier</key>\n")
+    f.write(f"\t<string>{identifier}</string>\n")
+    f.write(f"\t<key>CFBundleInfoDictionaryVersion</key>\n")
+    f.write(f"\t<string>6.0</string>\n")
+    f.write(f"\t<key>CFBundleName</key>\n")
+    f.write(f"\t<string>{name}</string>\n")
+    f.write(f"\t<key>CFBundlePackageType</key>\n")
+    f.write(f"\t<string>FMWK</string>\n")
+    f.write(f"\t<key>CFBundleShortVersionString</key>\n")
+    f.write(f"\t<string>1.0.0</string>\n")
+    f.write(f"\t<key>CFBundleSupportedPlatforms</key>\n")
+    f.write(f"\t<array>\n")
+    f.write(f"\t\t<string>MacOSX</string>\n")
+    f.write(f"\t</array>\n")
+    f.write(f"\t<key>CFBundleVersion</key>\n")
+    f.write(f"\t<string>1.0.0</string>\n")
+    f.write(f"\t<key>LSMinimumSystemVersion</key>\n")
+    f.write(f"\t<string>10.14</string>\n")
+    f.write(f"</dict>\n")
+    f.write(f"</plist>\n")
diff --git a/modules/text_server_adv/gdextension_build/text_server_adv.gdextension b/modules/text_server_adv/gdextension_build/text_server_adv.gdextension
new file mode 100644
index 0000000000..5956476a5e
--- /dev/null
+++ b/modules/text_server_adv/gdextension_build/text_server_adv.gdextension
@@ -0,0 +1,12 @@
+[configuration]
+
+entry_symbol = "textserver_advanced_init"
+
+[libraries]
+
+linux.64.debug = "bin/libtextserver_advanced.linux.debug.64.so"
+linux.64.release = "bin/libtextserver_advanced.linux.release.64.so"
+windows.64.debug = "bin/libtextserver_advanced.windows.debug.64.dll"
+windows.64.release = "bin/libtextserver_advanced.windows.release.64.dll"
+macos.debug = "bin/libtextserver_advanced.osx.debug.framework"
+macos.release = "bin/libtextserver_advanced.osx.release.framework"
diff --git a/modules/text_server_adv/register_types.cpp b/modules/text_server_adv/register_types.cpp
index d2dbfa045b..ed00bdfbf9 100644
--- a/modules/text_server_adv/register_types.cpp
+++ b/modules/text_server_adv/register_types.cpp
@@ -34,10 +34,11 @@
 
 void preregister_text_server_adv_types() {
 	GDREGISTER_CLASS(TextServerAdvanced);
-	if (TextServerManager::get_singleton()) {
+	TextServerManager *tsman = TextServerManager::get_singleton();
+	if (tsman) {
 		Ref<TextServerAdvanced> ts;
 		ts.instantiate();
-		TextServerManager::get_singleton()->add_interface(ts);
+		tsman->add_interface(ts);
 	}
 }
 
@@ -46,3 +47,26 @@ void register_text_server_adv_types() {
 
 void unregister_text_server_adv_types() {
 }
+
+#ifdef GDEXTENSION
+
+#include <godot_cpp/core/class_db.hpp>
+#include <godot_cpp/core/defs.hpp>
+#include <godot_cpp/core/memory.hpp>
+
+using namespace godot;
+
+extern "C" {
+
+GDNativeBool GDN_EXPORT textserver_advanced_init(const GDNativeInterface *p_interface, const GDNativeExtensionClassLibraryPtr p_library, GDNativeInitialization *r_initialization) {
+	GDExtensionBinding::InitObject init_obj(p_interface, p_library, r_initialization);
+
+	init_obj.register_server_initializer(&preregister_text_server_adv_types);
+	init_obj.register_server_terminator(&unregister_text_server_adv_types);
+
+	return init_obj.init();
+}
+
+} // ! extern "C"
+
+#endif // ! GDEXTENSION
diff --git a/modules/text_server_adv/script_iterator.h b/modules/text_server_adv/script_iterator.h
index 1e11b51521..2bd045b91a 100644
--- a/modules/text_server_adv/script_iterator.h
+++ b/modules/text_server_adv/script_iterator.h
@@ -31,7 +31,22 @@
 #ifndef SCRIPT_ITERATOR_H
 #define SCRIPT_ITERATOR_H
 
-#include "servers/text_server.h"
+#ifdef GDEXTENSION
+
+// Headers for building as GDExtension plug-in.
+#include <godot_cpp/godot.hpp>
+#include <godot_cpp/templates/vector.hpp>
+#include <godot_cpp/variant/string.hpp>
+
+using namespace godot;
+
+#else
+
+// Headers for building as built-in module.
+#include "core/string/ustring.h"
+#include "core/templates/vector.h"
+
+#endif
 
 #include <unicode/uchar.h>
 #include <unicode/uloc.h>
diff --git a/modules/text_server_adv/text_server_adv.cpp b/modules/text_server_adv/text_server_adv.cpp
index 7fd9cd42ed..b5912893b1 100644
--- a/modules/text_server_adv/text_server_adv.cpp
+++ b/modules/text_server_adv/text_server_adv.cpp
@@ -30,15 +30,37 @@
 
 #include "text_server_adv.h"
 
+#ifdef GDEXTENSION
+// Headers for building as GDExtension plug-in.
+
+#include <godot_cpp/classes/file.hpp>
+#include <godot_cpp/classes/rendering_server.hpp>
+#include <godot_cpp/classes/translation_server.hpp>
+#include <godot_cpp/core/error_macros.hpp>
+
+using namespace godot;
+
+#else
+// Headers for building as built-in module.
+
+#include "core/core_bind.h"
 #include "core/error/error_macros.h"
 #include "core/string/print_string.h"
 #include "core/string/translation.h"
 
+#include "modules/modules_enabled.gen.h" // For freetype, msdfgen.
+
+using namespace core_bind;
+
+#endif
+
+// Built-in ICU data.
+
 #ifdef ICU_STATIC_DATA
-#include "thirdparty/icu4c/icudata.gen.h"
+#include "icudata.gen.h"
 #endif
 
-#include "modules/modules_enabled.gen.h" // For freetype, msdfgen.
+// Thirdparty headers.
 
 #ifdef MODULE_MSDFGEN_ENABLED
 #include "core/ShapeDistanceFinder.h"
@@ -79,8 +101,8 @@ hb_bool_t TextServerAdvanced::_bmp_get_nominal_glyph(hb_font_t *p_font, void *p_
 	}
 
 	if (!bm_font->face->glyph_map.has(p_unicode)) {
-		if (bm_font->face->glyph_map.has(0xF000u + p_unicode)) {
-			*r_glyph = 0xF000u + p_unicode;
+		if (bm_font->face->glyph_map.has(0xf000u + p_unicode)) {
+			*r_glyph = 0xf000u + p_unicode;
 			return true;
 		} else {
 			return false;
@@ -305,22 +327,52 @@ _FORCE_INLINE_ bool is_connected_to_prev(char32_t p_chr, char32_t p_pchr) {
 
 /*************************************************************************/
 
-String TextServerAdvanced::interface_name = "ICU / HarfBuzz / Graphite";
-uint32_t TextServerAdvanced::interface_features = FEATURE_BIDI_LAYOUT | FEATURE_VERTICAL_LAYOUT | FEATURE_SHAPING | FEATURE_KASHIDA_JUSTIFICATION | FEATURE_BREAK_ITERATORS | FEATURE_USE_SUPPORT_DATA | FEATURE_FONT_VARIABLE | FEATURE_CONTEXT_SENSITIVE_CASE_CONVERSION;
-
 bool TextServerAdvanced::has_feature(Feature p_feature) const {
-	return (interface_features & p_feature) == p_feature;
+	switch (p_feature) {
+		case FEATURE_SIMPLE_LAYOUT:
+		case FEATURE_BIDI_LAYOUT:
+		case FEATURE_VERTICAL_LAYOUT:
+		case FEATURE_SHAPING:
+		case FEATURE_KASHIDA_JUSTIFICATION:
+		case FEATURE_BREAK_ITERATORS:
+		case FEATURE_FONT_BITMAP:
+#ifdef MODULE_FREETYPE_ENABLED
+		case FEATURE_FONT_DYNAMIC:
+#endif
+#ifdef MODULE_MSDFGEN_ENABLED
+		case FEATURE_FONT_MSDF:
+#endif
+		case FEATURE_FONT_VARIABLE:
+		case FEATURE_CONTEXT_SENSITIVE_CASE_CONVERSION:
+		case FEATURE_USE_SUPPORT_DATA:
+			return true;
+		default: {
+		}
+	}
+	return false;
 }
 
 String TextServerAdvanced::get_name() const {
-	return interface_name;
+#ifdef GDEXTENSION
+	return "ICU / HarfBuzz / Graphite (GDExtension)";
+#else
+	return "ICU / HarfBuzz / Graphite (Built-in)";
+#endif
 }
 
-uint32_t TextServerAdvanced::get_features() const {
+int64_t TextServerAdvanced::get_features() const {
+	int64_t interface_features = FEATURE_SIMPLE_LAYOUT | FEATURE_BIDI_LAYOUT | FEATURE_VERTICAL_LAYOUT | FEATURE_SHAPING | FEATURE_KASHIDA_JUSTIFICATION | FEATURE_BREAK_ITERATORS | FEATURE_FONT_BITMAP | FEATURE_FONT_VARIABLE | FEATURE_CONTEXT_SENSITIVE_CASE_CONVERSION | FEATURE_USE_SUPPORT_DATA;
+#ifdef MODULE_FREETYPE_ENABLED
+	interface_features |= FEATURE_FONT_DYNAMIC;
+#endif
+#ifdef MODULE_MSDFGEN_ENABLED
+	interface_features |= FEATURE_FONT_MSDF;
+#endif
+
 	return interface_features;
 }
 
-void TextServerAdvanced::free(RID p_rid) {
+void TextServerAdvanced::free_rid(const RID &p_rid) {
 	_THREAD_SAFE_METHOD_
 	if (font_owner.owns(p_rid)) {
 		FontDataAdvanced *fd = font_owner.get_or_null(p_rid);
@@ -333,7 +385,7 @@ void TextServerAdvanced::free(RID p_rid) {
 	}
 }
 
-bool TextServerAdvanced::has(RID p_rid) {
+bool TextServerAdvanced::has(const RID &p_rid) {
 	_THREAD_SAFE_METHOD_
 	return font_owner.owns(p_rid) || shaped_owner.owns(p_rid);
 }
@@ -342,43 +394,36 @@ bool TextServerAdvanced::load_support_data(const String &p_filename) {
 	_THREAD_SAFE_METHOD_
 
 #ifdef ICU_STATIC_DATA
-	if (icu_data == nullptr) {
+	if (!icu_data_loaded) {
 		UErrorCode err = U_ZERO_ERROR;
 		u_init(&err); // Do not check for errors, since we only load part of the data.
-		icu_data = (uint8_t *)&U_ICUDATA_ENTRY_POINT;
+		icu_data_loaded = true;
 	}
 #else
-	if (icu_data == nullptr) {
+	if (!icu_data_loaded) {
 		String filename = (p_filename.is_empty()) ? String("res://") + _MKSTR(ICU_DATA_NAME) : p_filename;
 
-		FileAccess *f = FileAccess::open(filename, FileAccess::READ);
-		if (!f) {
+		Ref<File> f;
+		f.instantiate();
+		if (f->open(filename, File::READ) != OK) {
 			return false;
 		}
-
-		UErrorCode err = U_ZERO_ERROR;
-
-		// ICU data found.
 		uint64_t len = f->get_length();
-		icu_data = (uint8_t *)memalloc(len);
-		f->get_buffer(icu_data, len);
+		PackedByteArray icu_data = f->get_buffer(len);
 		f->close();
-		memdelete(f);
 
-		udata_setCommonData(icu_data, &err);
+		UErrorCode err = U_ZERO_ERROR;
+		udata_setCommonData(icu_data.ptr(), &err);
 		if (U_FAILURE(err)) {
-			memfree(icu_data);
-			icu_data = nullptr;
 			ERR_FAIL_V_MSG(false, u_errorName(err));
 		}
 
 		err = U_ZERO_ERROR;
 		u_init(&err);
 		if (U_FAILURE(err)) {
-			memfree(icu_data);
-			icu_data = nullptr;
 			ERR_FAIL_V_MSG(false, u_errorName(err));
 		}
+		icu_data_loaded = true;
 	}
 #endif
 	return true;
@@ -405,13 +450,18 @@ bool TextServerAdvanced::save_support_data(const String &p_filename) const {
 #ifdef ICU_STATIC_DATA
 
 	// Store data to the res file if it's available.
-	FileAccess *f = FileAccess::open(p_filename, FileAccess::WRITE);
-	if (!f) {
+
+	Ref<File> f;
+	f.instantiate();
+	if (f->open(p_filename, File::WRITE) != OK) {
 		return false;
 	}
-	f->store_buffer(U_ICUDATA_ENTRY_POINT, U_ICUDATA_SIZE);
+
+	PackedByteArray icu_data;
+	icu_data.resize(U_ICUDATA_SIZE);
+	memcpy(icu_data.ptrw(), U_ICUDATA_ENTRY_POINT, U_ICUDATA_SIZE);
+	f->store_buffer(icu_data);
 	f->close();
-	memdelete(f);
 	return true;
 
 #else
@@ -428,256 +478,262 @@ bool TextServerAdvanced::is_locale_right_to_left(const String &p_locale) const {
 	}
 }
 
+_FORCE_INLINE_ void TextServerAdvanced::_insert_feature(const StringName &p_name, int32_t p_tag) {
+	feature_sets.insert(p_name, p_tag);
+	feature_sets_inv.insert(p_tag, p_name);
+}
+
 void TextServerAdvanced::_insert_feature_sets() {
 	// Registered OpenType feature tags.
-	feature_sets.insert("access_all_alternates", HB_TAG('a', 'a', 'l', 't'));
-	feature_sets.insert("above_base_forms", HB_TAG('a', 'b', 'v', 'f'));
-	feature_sets.insert("above_base_mark_positioning", HB_TAG('a', 'b', 'v', 'm'));
-	feature_sets.insert("above_base_substitutions", HB_TAG('a', 'b', 'v', 's'));
-	feature_sets.insert("alternative_fractions", HB_TAG('a', 'f', 'r', 'c'));
-	feature_sets.insert("akhands", HB_TAG('a', 'k', 'h', 'n'));
-	feature_sets.insert("below_base_forms", HB_TAG('b', 'l', 'w', 'f'));
-	feature_sets.insert("below_base_mark_positioning", HB_TAG('b', 'l', 'w', 'm'));
-	feature_sets.insert("below_base_substitutions", HB_TAG('b', 'l', 'w', 's'));
-	feature_sets.insert("contextual_alternates", HB_TAG('c', 'a', 'l', 't'));
-	feature_sets.insert("case_sensitive_forms", HB_TAG('c', 'a', 's', 'e'));
-	feature_sets.insert("glyph_composition", HB_TAG('c', 'c', 'm', 'p'));
-	feature_sets.insert("conjunct_form_after_ro", HB_TAG('c', 'f', 'a', 'r'));
-	feature_sets.insert("conjunct_forms", HB_TAG('c', 'j', 'c', 't'));
-	feature_sets.insert("contextual_ligatures", HB_TAG('c', 'l', 'i', 'g'));
-	feature_sets.insert("centered_cjk_punctuation", HB_TAG('c', 'p', 'c', 't'));
-	feature_sets.insert("capital_spacing", HB_TAG('c', 'p', 's', 'p'));
-	feature_sets.insert("contextual_swash", HB_TAG('c', 's', 'w', 'h'));
-	feature_sets.insert("cursive_positioning", HB_TAG('c', 'u', 'r', 's'));
-	feature_sets.insert("character_variant_01", HB_TAG('c', 'v', '0', '1'));
-	feature_sets.insert("character_variant_02", HB_TAG('c', 'v', '0', '2'));
-	feature_sets.insert("character_variant_03", HB_TAG('c', 'v', '0', '3'));
-	feature_sets.insert("character_variant_04", HB_TAG('c', 'v', '0', '4'));
-	feature_sets.insert("character_variant_05", HB_TAG('c', 'v', '0', '5'));
-	feature_sets.insert("character_variant_06", HB_TAG('c', 'v', '0', '6'));
-	feature_sets.insert("character_variant_07", HB_TAG('c', 'v', '0', '7'));
-	feature_sets.insert("character_variant_08", HB_TAG('c', 'v', '0', '8'));
-	feature_sets.insert("character_variant_09", HB_TAG('c', 'v', '0', '9'));
-	feature_sets.insert("character_variant_10", HB_TAG('c', 'v', '1', '0'));
-	feature_sets.insert("character_variant_11", HB_TAG('c', 'v', '1', '1'));
-	feature_sets.insert("character_variant_12", HB_TAG('c', 'v', '1', '2'));
-	feature_sets.insert("character_variant_13", HB_TAG('c', 'v', '1', '3'));
-	feature_sets.insert("character_variant_14", HB_TAG('c', 'v', '1', '4'));
-	feature_sets.insert("character_variant_15", HB_TAG('c', 'v', '1', '5'));
-	feature_sets.insert("character_variant_16", HB_TAG('c', 'v', '1', '6'));
-	feature_sets.insert("character_variant_17", HB_TAG('c', 'v', '1', '7'));
-	feature_sets.insert("character_variant_18", HB_TAG('c', 'v', '1', '8'));
-	feature_sets.insert("character_variant_19", HB_TAG('c', 'v', '1', '9'));
-	feature_sets.insert("character_variant_20", HB_TAG('c', 'v', '2', '0'));
-	feature_sets.insert("character_variant_21", HB_TAG('c', 'v', '2', '1'));
-	feature_sets.insert("character_variant_22", HB_TAG('c', 'v', '2', '2'));
-	feature_sets.insert("character_variant_23", HB_TAG('c', 'v', '2', '3'));
-	feature_sets.insert("character_variant_24", HB_TAG('c', 'v', '2', '4'));
-	feature_sets.insert("character_variant_25", HB_TAG('c', 'v', '2', '5'));
-	feature_sets.insert("character_variant_26", HB_TAG('c', 'v', '2', '6'));
-	feature_sets.insert("character_variant_27", HB_TAG('c', 'v', '2', '7'));
-	feature_sets.insert("character_variant_28", HB_TAG('c', 'v', '2', '8'));
-	feature_sets.insert("character_variant_29", HB_TAG('c', 'v', '2', '9'));
-	feature_sets.insert("character_variant_30", HB_TAG('c', 'v', '3', '0'));
-	feature_sets.insert("character_variant_31", HB_TAG('c', 'v', '3', '1'));
-	feature_sets.insert("character_variant_32", HB_TAG('c', 'v', '3', '2'));
-	feature_sets.insert("character_variant_33", HB_TAG('c', 'v', '3', '3'));
-	feature_sets.insert("character_variant_34", HB_TAG('c', 'v', '3', '4'));
-	feature_sets.insert("character_variant_35", HB_TAG('c', 'v', '3', '5'));
-	feature_sets.insert("character_variant_36", HB_TAG('c', 'v', '3', '6'));
-	feature_sets.insert("character_variant_37", HB_TAG('c', 'v', '3', '7'));
-	feature_sets.insert("character_variant_38", HB_TAG('c', 'v', '3', '8'));
-	feature_sets.insert("character_variant_39", HB_TAG('c', 'v', '3', '9'));
-	feature_sets.insert("character_variant_40", HB_TAG('c', 'v', '4', '0'));
-	feature_sets.insert("character_variant_41", HB_TAG('c', 'v', '4', '1'));
-	feature_sets.insert("character_variant_42", HB_TAG('c', 'v', '4', '2'));
-	feature_sets.insert("character_variant_43", HB_TAG('c', 'v', '4', '3'));
-	feature_sets.insert("character_variant_44", HB_TAG('c', 'v', '4', '4'));
-	feature_sets.insert("character_variant_45", HB_TAG('c', 'v', '4', '5'));
-	feature_sets.insert("character_variant_46", HB_TAG('c', 'v', '4', '6'));
-	feature_sets.insert("character_variant_47", HB_TAG('c', 'v', '4', '7'));
-	feature_sets.insert("character_variant_48", HB_TAG('c', 'v', '4', '8'));
-	feature_sets.insert("character_variant_49", HB_TAG('c', 'v', '4', '9'));
-	feature_sets.insert("character_variant_50", HB_TAG('c', 'v', '5', '0'));
-	feature_sets.insert("character_variant_51", HB_TAG('c', 'v', '5', '1'));
-	feature_sets.insert("character_variant_52", HB_TAG('c', 'v', '5', '2'));
-	feature_sets.insert("character_variant_53", HB_TAG('c', 'v', '5', '3'));
-	feature_sets.insert("character_variant_54", HB_TAG('c', 'v', '5', '4'));
-	feature_sets.insert("character_variant_55", HB_TAG('c', 'v', '5', '5'));
-	feature_sets.insert("character_variant_56", HB_TAG('c', 'v', '5', '6'));
-	feature_sets.insert("character_variant_57", HB_TAG('c', 'v', '5', '7'));
-	feature_sets.insert("character_variant_58", HB_TAG('c', 'v', '5', '8'));
-	feature_sets.insert("character_variant_59", HB_TAG('c', 'v', '5', '9'));
-	feature_sets.insert("character_variant_60", HB_TAG('c', 'v', '6', '0'));
-	feature_sets.insert("character_variant_61", HB_TAG('c', 'v', '6', '1'));
-	feature_sets.insert("character_variant_62", HB_TAG('c', 'v', '6', '2'));
-	feature_sets.insert("character_variant_63", HB_TAG('c', 'v', '6', '3'));
-	feature_sets.insert("character_variant_64", HB_TAG('c', 'v', '6', '4'));
-	feature_sets.insert("character_variant_65", HB_TAG('c', 'v', '6', '5'));
-	feature_sets.insert("character_variant_66", HB_TAG('c', 'v', '6', '6'));
-	feature_sets.insert("character_variant_67", HB_TAG('c', 'v', '6', '7'));
-	feature_sets.insert("character_variant_68", HB_TAG('c', 'v', '6', '8'));
-	feature_sets.insert("character_variant_69", HB_TAG('c', 'v', '6', '9'));
-	feature_sets.insert("character_variant_70", HB_TAG('c', 'v', '7', '0'));
-	feature_sets.insert("character_variant_71", HB_TAG('c', 'v', '7', '1'));
-	feature_sets.insert("character_variant_72", HB_TAG('c', 'v', '7', '2'));
-	feature_sets.insert("character_variant_73", HB_TAG('c', 'v', '7', '3'));
-	feature_sets.insert("character_variant_74", HB_TAG('c', 'v', '7', '4'));
-	feature_sets.insert("character_variant_75", HB_TAG('c', 'v', '7', '5'));
-	feature_sets.insert("character_variant_76", HB_TAG('c', 'v', '7', '6'));
-	feature_sets.insert("character_variant_77", HB_TAG('c', 'v', '7', '7'));
-	feature_sets.insert("character_variant_78", HB_TAG('c', 'v', '7', '8'));
-	feature_sets.insert("character_variant_79", HB_TAG('c', 'v', '7', '9'));
-	feature_sets.insert("character_variant_80", HB_TAG('c', 'v', '8', '0'));
-	feature_sets.insert("character_variant_81", HB_TAG('c', 'v', '8', '1'));
-	feature_sets.insert("character_variant_82", HB_TAG('c', 'v', '8', '2'));
-	feature_sets.insert("character_variant_83", HB_TAG('c', 'v', '8', '3'));
-	feature_sets.insert("character_variant_84", HB_TAG('c', 'v', '8', '4'));
-	feature_sets.insert("character_variant_85", HB_TAG('c', 'v', '8', '5'));
-	feature_sets.insert("character_variant_86", HB_TAG('c', 'v', '8', '6'));
-	feature_sets.insert("character_variant_87", HB_TAG('c', 'v', '8', '7'));
-	feature_sets.insert("character_variant_88", HB_TAG('c', 'v', '8', '8'));
-	feature_sets.insert("character_variant_89", HB_TAG('c', 'v', '8', '9'));
-	feature_sets.insert("character_variant_90", HB_TAG('c', 'v', '9', '0'));
-	feature_sets.insert("character_variant_91", HB_TAG('c', 'v', '9', '1'));
-	feature_sets.insert("character_variant_92", HB_TAG('c', 'v', '9', '2'));
-	feature_sets.insert("character_variant_93", HB_TAG('c', 'v', '9', '3'));
-	feature_sets.insert("character_variant_94", HB_TAG('c', 'v', '9', '4'));
-	feature_sets.insert("character_variant_95", HB_TAG('c', 'v', '9', '5'));
-	feature_sets.insert("character_variant_96", HB_TAG('c', 'v', '9', '6'));
-	feature_sets.insert("character_variant_97", HB_TAG('c', 'v', '9', '7'));
-	feature_sets.insert("character_variant_98", HB_TAG('c', 'v', '9', '8'));
-	feature_sets.insert("character_variant_99", HB_TAG('c', 'v', '9', '9'));
-	feature_sets.insert("petite_capitals_from_capitals", HB_TAG('c', '2', 'p', 'c'));
-	feature_sets.insert("small_capitals_from_capitals", HB_TAG('c', '2', 's', 'c'));
-	feature_sets.insert("distances", HB_TAG('d', 'i', 's', 't'));
-	feature_sets.insert("discretionary_ligatures", HB_TAG('d', 'l', 'i', 'g'));
-	feature_sets.insert("denominators", HB_TAG('d', 'n', 'o', 'm'));
-	feature_sets.insert("dotless_forms", HB_TAG('d', 't', 'l', 's'));
-	feature_sets.insert("expert_forms", HB_TAG('e', 'x', 'p', 't'));
-	feature_sets.insert("final_glyph_on_line_alternates", HB_TAG('f', 'a', 'l', 't'));
-	feature_sets.insert("terminal_forms_2", HB_TAG('f', 'i', 'n', '2'));
-	feature_sets.insert("terminal_forms_3", HB_TAG('f', 'i', 'n', '3'));
-	feature_sets.insert("terminal_forms", HB_TAG('f', 'i', 'n', 'a'));
-	feature_sets.insert("flattened_accent_forms", HB_TAG('f', 'l', 'a', 'c'));
-	feature_sets.insert("fractions", HB_TAG('f', 'r', 'a', 'c'));
-	feature_sets.insert("full_widths", HB_TAG('f', 'w', 'i', 'd'));
-	feature_sets.insert("half_forms", HB_TAG('h', 'a', 'l', 'f'));
-	feature_sets.insert("halant_forms", HB_TAG('h', 'a', 'l', 'n'));
-	feature_sets.insert("alternate_half_widths", HB_TAG('h', 'a', 'l', 't'));
-	feature_sets.insert("historical_forms", HB_TAG('h', 'i', 's', 't'));
-	feature_sets.insert("horizontal_kana_alternates", HB_TAG('h', 'k', 'n', 'a'));
-	feature_sets.insert("historical_ligatures", HB_TAG('h', 'l', 'i', 'g'));
-	feature_sets.insert("hangul", HB_TAG('h', 'n', 'g', 'l'));
-	feature_sets.insert("hojo_kanji_forms", HB_TAG('h', 'o', 'j', 'o'));
-	feature_sets.insert("half_widths", HB_TAG('h', 'w', 'i', 'd'));
-	feature_sets.insert("initial_forms", HB_TAG('i', 'n', 'i', 't'));
-	feature_sets.insert("isolated_forms", HB_TAG('i', 's', 'o', 'l'));
-	feature_sets.insert("italics", HB_TAG('i', 't', 'a', 'l'));
-	feature_sets.insert("justification_alternates", HB_TAG('j', 'a', 'l', 't'));
-	feature_sets.insert("jis78_forms", HB_TAG('j', 'p', '7', '8'));
-	feature_sets.insert("jis83_forms", HB_TAG('j', 'p', '8', '3'));
-	feature_sets.insert("jis90_forms", HB_TAG('j', 'p', '9', '0'));
-	feature_sets.insert("jis2004_forms", HB_TAG('j', 'p', '0', '4'));
-	feature_sets.insert("kerning", HB_TAG('k', 'e', 'r', 'n'));
-	feature_sets.insert("left_bounds", HB_TAG('l', 'f', 'b', 'd'));
-	feature_sets.insert("standard_ligatures", HB_TAG('l', 'i', 'g', 'a'));
-	feature_sets.insert("leading_jamo_forms", HB_TAG('l', 'j', 'm', 'o'));
-	feature_sets.insert("lining_figures", HB_TAG('l', 'n', 'u', 'm'));
-	feature_sets.insert("localized_forms", HB_TAG('l', 'o', 'c', 'l'));
-	feature_sets.insert("left_to_right_alternates", HB_TAG('l', 't', 'r', 'a'));
-	feature_sets.insert("left_to_right_mirrored_forms", HB_TAG('l', 't', 'r', 'm'));
-	feature_sets.insert("mark_positioning", HB_TAG('m', 'a', 'r', 'k'));
-	feature_sets.insert("medial_forms_2", HB_TAG('m', 'e', 'd', '2'));
-	feature_sets.insert("medial_forms", HB_TAG('m', 'e', 'd', 'i'));
-	feature_sets.insert("mathematical_greek", HB_TAG('m', 'g', 'r', 'k'));
-	feature_sets.insert("mark_to_mark_positioning", HB_TAG('m', 'k', 'm', 'k'));
-	feature_sets.insert("mark_positioning_via_substitution", HB_TAG('m', 's', 'e', 't'));
-	feature_sets.insert("alternate_annotation_forms", HB_TAG('n', 'a', 'l', 't'));
-	feature_sets.insert("nlc_kanji_forms", HB_TAG('n', 'l', 'c', 'k'));
-	feature_sets.insert("nukta_forms", HB_TAG('n', 'u', 'k', 't'));
-	feature_sets.insert("numerators", HB_TAG('n', 'u', 'm', 'r'));
-	feature_sets.insert("oldstyle_figures", HB_TAG('o', 'n', 'u', 'm'));
-	feature_sets.insert("optical_bounds", HB_TAG('o', 'p', 'b', 'd'));
-	feature_sets.insert("ordinals", HB_TAG('o', 'r', 'd', 'n'));
-	feature_sets.insert("ornaments", HB_TAG('o', 'r', 'n', 'm'));
-	feature_sets.insert("proportional_alternate_widths", HB_TAG('p', 'a', 'l', 't'));
-	feature_sets.insert("petite_capitals", HB_TAG('p', 'c', 'a', 'p'));
-	feature_sets.insert("proportional_kana", HB_TAG('p', 'k', 'n', 'a'));
-	feature_sets.insert("proportional_figures", HB_TAG('p', 'n', 'u', 'm'));
-	feature_sets.insert("pre_base_forms", HB_TAG('p', 'r', 'e', 'f'));
-	feature_sets.insert("pre_base_substitutions", HB_TAG('p', 'r', 'e', 's'));
-	feature_sets.insert("post_base_forms", HB_TAG('p', 's', 't', 'f'));
-	feature_sets.insert("post_base_substitutions", HB_TAG('p', 's', 't', 's'));
-	feature_sets.insert("proportional_widths", HB_TAG('p', 'w', 'i', 'd'));
-	feature_sets.insert("quarter_widths", HB_TAG('q', 'w', 'i', 'd'));
-	feature_sets.insert("randomize", HB_TAG('r', 'a', 'n', 'd'));
-	feature_sets.insert("required_contextual_alternates", HB_TAG('r', 'c', 'l', 't'));
-	feature_sets.insert("rakar_forms", HB_TAG('r', 'k', 'r', 'f'));
-	feature_sets.insert("required_ligatures", HB_TAG('r', 'l', 'i', 'g'));
-	feature_sets.insert("reph_forms", HB_TAG('r', 'p', 'h', 'f'));
-	feature_sets.insert("right_bounds", HB_TAG('r', 't', 'b', 'd'));
-	feature_sets.insert("right_to_left_alternates", HB_TAG('r', 't', 'l', 'a'));
-	feature_sets.insert("right_to_left_mirrored_forms", HB_TAG('r', 't', 'l', 'm'));
-	feature_sets.insert("ruby_notation_forms", HB_TAG('r', 'u', 'b', 'y'));
-	feature_sets.insert("required_variation_alternates", HB_TAG('r', 'v', 'r', 'n'));
-	feature_sets.insert("stylistic_alternates", HB_TAG('s', 'a', 'l', 't'));
-	feature_sets.insert("scientific_inferiors", HB_TAG('s', 'i', 'n', 'f'));
-	feature_sets.insert("optical_size", HB_TAG('s', 'i', 'z', 'e'));
-	feature_sets.insert("small_capitals", HB_TAG('s', 'm', 'c', 'p'));
-	feature_sets.insert("simplified_forms", HB_TAG('s', 'm', 'p', 'l'));
-	feature_sets.insert("stylistic_set_01", HB_TAG('s', 's', '0', '1'));
-	feature_sets.insert("stylistic_set_02", HB_TAG('s', 's', '0', '2'));
-	feature_sets.insert("stylistic_set_03", HB_TAG('s', 's', '0', '3'));
-	feature_sets.insert("stylistic_set_04", HB_TAG('s', 's', '0', '4'));
-	feature_sets.insert("stylistic_set_05", HB_TAG('s', 's', '0', '5'));
-	feature_sets.insert("stylistic_set_06", HB_TAG('s', 's', '0', '6'));
-	feature_sets.insert("stylistic_set_07", HB_TAG('s', 's', '0', '7'));
-	feature_sets.insert("stylistic_set_08", HB_TAG('s', 's', '0', '8'));
-	feature_sets.insert("stylistic_set_09", HB_TAG('s', 's', '0', '9'));
-	feature_sets.insert("stylistic_set_10", HB_TAG('s', 's', '1', '0'));
-	feature_sets.insert("stylistic_set_11", HB_TAG('s', 's', '1', '1'));
-	feature_sets.insert("stylistic_set_12", HB_TAG('s', 's', '1', '2'));
-	feature_sets.insert("stylistic_set_13", HB_TAG('s', 's', '1', '3'));
-	feature_sets.insert("stylistic_set_14", HB_TAG('s', 's', '1', '4'));
-	feature_sets.insert("stylistic_set_15", HB_TAG('s', 's', '1', '5'));
-	feature_sets.insert("stylistic_set_16", HB_TAG('s', 's', '1', '6'));
-	feature_sets.insert("stylistic_set_17", HB_TAG('s', 's', '1', '7'));
-	feature_sets.insert("stylistic_set_18", HB_TAG('s', 's', '1', '8'));
-	feature_sets.insert("stylistic_set_19", HB_TAG('s', 's', '1', '9'));
-	feature_sets.insert("stylistic_set_20", HB_TAG('s', 's', '2', '0'));
-	feature_sets.insert("math_script_style_alternates", HB_TAG('s', 's', 't', 'y'));
-	feature_sets.insert("stretching_glyph_decomposition", HB_TAG('s', 't', 'c', 'h'));
-	feature_sets.insert("subscript", HB_TAG('s', 'u', 'b', 's'));
-	feature_sets.insert("superscript", HB_TAG('s', 'u', 'p', 's'));
-	feature_sets.insert("swash", HB_TAG('s', 'w', 's', 'h'));
-	feature_sets.insert("titling", HB_TAG('t', 'i', 't', 'l'));
-	feature_sets.insert("trailing_jamo_forms", HB_TAG('t', 'j', 'm', 'o'));
-	feature_sets.insert("traditional_name_forms", HB_TAG('t', 'n', 'a', 'm'));
-	feature_sets.insert("tabular_figures", HB_TAG('t', 'n', 'u', 'm'));
-	feature_sets.insert("traditional_forms", HB_TAG('t', 'r', 'a', 'd'));
-	feature_sets.insert("third_widths", HB_TAG('t', 'w', 'i', 'd'));
-	feature_sets.insert("unicase", HB_TAG('u', 'n', 'i', 'c'));
-	feature_sets.insert("alternate_vertical_metrics", HB_TAG('v', 'a', 'l', 't'));
-	feature_sets.insert("vattu_variants", HB_TAG('v', 'a', 't', 'u'));
-	feature_sets.insert("vertical_writing", HB_TAG('v', 'e', 'r', 't'));
-	feature_sets.insert("alternate_vertical_half_metrics", HB_TAG('v', 'h', 'a', 'l'));
-	feature_sets.insert("vowel_jamo_forms", HB_TAG('v', 'j', 'm', 'o'));
-	feature_sets.insert("vertical_kana_alternates", HB_TAG('v', 'k', 'n', 'a'));
-	feature_sets.insert("vertical_kerning", HB_TAG('v', 'k', 'r', 'n'));
-	feature_sets.insert("proportional_alternate_vertical_metrics", HB_TAG('v', 'p', 'a', 'l'));
-	feature_sets.insert("vertical_alternates_and_rotation", HB_TAG('v', 'r', 't', '2'));
-	feature_sets.insert("vertical_alternates_for_rotation", HB_TAG('v', 'r', 't', 'r'));
-	feature_sets.insert("slashed_zero", HB_TAG('z', 'e', 'r', 'o'));
+	_insert_feature("access_all_alternates", HB_TAG('a', 'a', 'l', 't'));
+	_insert_feature("above_base_forms", HB_TAG('a', 'b', 'v', 'f'));
+	_insert_feature("above_base_mark_positioning", HB_TAG('a', 'b', 'v', 'm'));
+	_insert_feature("above_base_substitutions", HB_TAG('a', 'b', 'v', 's'));
+	_insert_feature("alternative_fractions", HB_TAG('a', 'f', 'r', 'c'));
+	_insert_feature("akhands", HB_TAG('a', 'k', 'h', 'n'));
+	_insert_feature("below_base_forms", HB_TAG('b', 'l', 'w', 'f'));
+	_insert_feature("below_base_mark_positioning", HB_TAG('b', 'l', 'w', 'm'));
+	_insert_feature("below_base_substitutions", HB_TAG('b', 'l', 'w', 's'));
+	_insert_feature("contextual_alternates", HB_TAG('c', 'a', 'l', 't'));
+	_insert_feature("case_sensitive_forms", HB_TAG('c', 'a', 's', 'e'));
+	_insert_feature("glyph_composition", HB_TAG('c', 'c', 'm', 'p'));
+	_insert_feature("conjunct_form_after_ro", HB_TAG('c', 'f', 'a', 'r'));
+	_insert_feature("conjunct_forms", HB_TAG('c', 'j', 'c', 't'));
+	_insert_feature("contextual_ligatures", HB_TAG('c', 'l', 'i', 'g'));
+	_insert_feature("centered_cjk_punctuation", HB_TAG('c', 'p', 'c', 't'));
+	_insert_feature("capital_spacing", HB_TAG('c', 'p', 's', 'p'));
+	_insert_feature("contextual_swash", HB_TAG('c', 's', 'w', 'h'));
+	_insert_feature("cursive_positioning", HB_TAG('c', 'u', 'r', 's'));
+	_insert_feature("character_variant_01", HB_TAG('c', 'v', '0', '1'));
+	_insert_feature("character_variant_02", HB_TAG('c', 'v', '0', '2'));
+	_insert_feature("character_variant_03", HB_TAG('c', 'v', '0', '3'));
+	_insert_feature("character_variant_04", HB_TAG('c', 'v', '0', '4'));
+	_insert_feature("character_variant_05", HB_TAG('c', 'v', '0', '5'));
+	_insert_feature("character_variant_06", HB_TAG('c', 'v', '0', '6'));
+	_insert_feature("character_variant_07", HB_TAG('c', 'v', '0', '7'));
+	_insert_feature("character_variant_08", HB_TAG('c', 'v', '0', '8'));
+	_insert_feature("character_variant_09", HB_TAG('c', 'v', '0', '9'));
+	_insert_feature("character_variant_10", HB_TAG('c', 'v', '1', '0'));
+	_insert_feature("character_variant_11", HB_TAG('c', 'v', '1', '1'));
+	_insert_feature("character_variant_12", HB_TAG('c', 'v', '1', '2'));
+	_insert_feature("character_variant_13", HB_TAG('c', 'v', '1', '3'));
+	_insert_feature("character_variant_14", HB_TAG('c', 'v', '1', '4'));
+	_insert_feature("character_variant_15", HB_TAG('c', 'v', '1', '5'));
+	_insert_feature("character_variant_16", HB_TAG('c', 'v', '1', '6'));
+	_insert_feature("character_variant_17", HB_TAG('c', 'v', '1', '7'));
+	_insert_feature("character_variant_18", HB_TAG('c', 'v', '1', '8'));
+	_insert_feature("character_variant_19", HB_TAG('c', 'v', '1', '9'));
+	_insert_feature("character_variant_20", HB_TAG('c', 'v', '2', '0'));
+	_insert_feature("character_variant_21", HB_TAG('c', 'v', '2', '1'));
+	_insert_feature("character_variant_22", HB_TAG('c', 'v', '2', '2'));
+	_insert_feature("character_variant_23", HB_TAG('c', 'v', '2', '3'));
+	_insert_feature("character_variant_24", HB_TAG('c', 'v', '2', '4'));
+	_insert_feature("character_variant_25", HB_TAG('c', 'v', '2', '5'));
+	_insert_feature("character_variant_26", HB_TAG('c', 'v', '2', '6'));
+	_insert_feature("character_variant_27", HB_TAG('c', 'v', '2', '7'));
+	_insert_feature("character_variant_28", HB_TAG('c', 'v', '2', '8'));
+	_insert_feature("character_variant_29", HB_TAG('c', 'v', '2', '9'));
+	_insert_feature("character_variant_30", HB_TAG('c', 'v', '3', '0'));
+	_insert_feature("character_variant_31", HB_TAG('c', 'v', '3', '1'));
+	_insert_feature("character_variant_32", HB_TAG('c', 'v', '3', '2'));
+	_insert_feature("character_variant_33", HB_TAG('c', 'v', '3', '3'));
+	_insert_feature("character_variant_34", HB_TAG('c', 'v', '3', '4'));
+	_insert_feature("character_variant_35", HB_TAG('c', 'v', '3', '5'));
+	_insert_feature("character_variant_36", HB_TAG('c', 'v', '3', '6'));
+	_insert_feature("character_variant_37", HB_TAG('c', 'v', '3', '7'));
+	_insert_feature("character_variant_38", HB_TAG('c', 'v', '3', '8'));
+	_insert_feature("character_variant_39", HB_TAG('c', 'v', '3', '9'));
+	_insert_feature("character_variant_40", HB_TAG('c', 'v', '4', '0'));
+	_insert_feature("character_variant_41", HB_TAG('c', 'v', '4', '1'));
+	_insert_feature("character_variant_42", HB_TAG('c', 'v', '4', '2'));
+	_insert_feature("character_variant_43", HB_TAG('c', 'v', '4', '3'));
+	_insert_feature("character_variant_44", HB_TAG('c', 'v', '4', '4'));
+	_insert_feature("character_variant_45", HB_TAG('c', 'v', '4', '5'));
+	_insert_feature("character_variant_46", HB_TAG('c', 'v', '4', '6'));
+	_insert_feature("character_variant_47", HB_TAG('c', 'v', '4', '7'));
+	_insert_feature("character_variant_48", HB_TAG('c', 'v', '4', '8'));
+	_insert_feature("character_variant_49", HB_TAG('c', 'v', '4', '9'));
+	_insert_feature("character_variant_50", HB_TAG('c', 'v', '5', '0'));
+	_insert_feature("character_variant_51", HB_TAG('c', 'v', '5', '1'));
+	_insert_feature("character_variant_52", HB_TAG('c', 'v', '5', '2'));
+	_insert_feature("character_variant_53", HB_TAG('c', 'v', '5', '3'));
+	_insert_feature("character_variant_54", HB_TAG('c', 'v', '5', '4'));
+	_insert_feature("character_variant_55", HB_TAG('c', 'v', '5', '5'));
+	_insert_feature("character_variant_56", HB_TAG('c', 'v', '5', '6'));
+	_insert_feature("character_variant_57", HB_TAG('c', 'v', '5', '7'));
+	_insert_feature("character_variant_58", HB_TAG('c', 'v', '5', '8'));
+	_insert_feature("character_variant_59", HB_TAG('c', 'v', '5', '9'));
+	_insert_feature("character_variant_60", HB_TAG('c', 'v', '6', '0'));
+	_insert_feature("character_variant_61", HB_TAG('c', 'v', '6', '1'));
+	_insert_feature("character_variant_62", HB_TAG('c', 'v', '6', '2'));
+	_insert_feature("character_variant_63", HB_TAG('c', 'v', '6', '3'));
+	_insert_feature("character_variant_64", HB_TAG('c', 'v', '6', '4'));
+	_insert_feature("character_variant_65", HB_TAG('c', 'v', '6', '5'));
+	_insert_feature("character_variant_66", HB_TAG('c', 'v', '6', '6'));
+	_insert_feature("character_variant_67", HB_TAG('c', 'v', '6', '7'));
+	_insert_feature("character_variant_68", HB_TAG('c', 'v', '6', '8'));
+	_insert_feature("character_variant_69", HB_TAG('c', 'v', '6', '9'));
+	_insert_feature("character_variant_70", HB_TAG('c', 'v', '7', '0'));
+	_insert_feature("character_variant_71", HB_TAG('c', 'v', '7', '1'));
+	_insert_feature("character_variant_72", HB_TAG('c', 'v', '7', '2'));
+	_insert_feature("character_variant_73", HB_TAG('c', 'v', '7', '3'));
+	_insert_feature("character_variant_74", HB_TAG('c', 'v', '7', '4'));
+	_insert_feature("character_variant_75", HB_TAG('c', 'v', '7', '5'));
+	_insert_feature("character_variant_76", HB_TAG('c', 'v', '7', '6'));
+	_insert_feature("character_variant_77", HB_TAG('c', 'v', '7', '7'));
+	_insert_feature("character_variant_78", HB_TAG('c', 'v', '7', '8'));
+	_insert_feature("character_variant_79", HB_TAG('c', 'v', '7', '9'));
+	_insert_feature("character_variant_80", HB_TAG('c', 'v', '8', '0'));
+	_insert_feature("character_variant_81", HB_TAG('c', 'v', '8', '1'));
+	_insert_feature("character_variant_82", HB_TAG('c', 'v', '8', '2'));
+	_insert_feature("character_variant_83", HB_TAG('c', 'v', '8', '3'));
+	_insert_feature("character_variant_84", HB_TAG('c', 'v', '8', '4'));
+	_insert_feature("character_variant_85", HB_TAG('c', 'v', '8', '5'));
+	_insert_feature("character_variant_86", HB_TAG('c', 'v', '8', '6'));
+	_insert_feature("character_variant_87", HB_TAG('c', 'v', '8', '7'));
+	_insert_feature("character_variant_88", HB_TAG('c', 'v', '8', '8'));
+	_insert_feature("character_variant_89", HB_TAG('c', 'v', '8', '9'));
+	_insert_feature("character_variant_90", HB_TAG('c', 'v', '9', '0'));
+	_insert_feature("character_variant_91", HB_TAG('c', 'v', '9', '1'));
+	_insert_feature("character_variant_92", HB_TAG('c', 'v', '9', '2'));
+	_insert_feature("character_variant_93", HB_TAG('c', 'v', '9', '3'));
+	_insert_feature("character_variant_94", HB_TAG('c', 'v', '9', '4'));
+	_insert_feature("character_variant_95", HB_TAG('c', 'v', '9', '5'));
+	_insert_feature("character_variant_96", HB_TAG('c', 'v', '9', '6'));
+	_insert_feature("character_variant_97", HB_TAG('c', 'v', '9', '7'));
+	_insert_feature("character_variant_98", HB_TAG('c', 'v', '9', '8'));
+	_insert_feature("character_variant_99", HB_TAG('c', 'v', '9', '9'));
+	_insert_feature("petite_capitals_from_capitals", HB_TAG('c', '2', 'p', 'c'));
+	_insert_feature("small_capitals_from_capitals", HB_TAG('c', '2', 's', 'c'));
+	_insert_feature("distances", HB_TAG('d', 'i', 's', 't'));
+	_insert_feature("discretionary_ligatures", HB_TAG('d', 'l', 'i', 'g'));
+	_insert_feature("denominators", HB_TAG('d', 'n', 'o', 'm'));
+	_insert_feature("dotless_forms", HB_TAG('d', 't', 'l', 's'));
+	_insert_feature("expert_forms", HB_TAG('e', 'x', 'p', 't'));
+	_insert_feature("final_glyph_on_line_alternates", HB_TAG('f', 'a', 'l', 't'));
+	_insert_feature("terminal_forms_2", HB_TAG('f', 'i', 'n', '2'));
+	_insert_feature("terminal_forms_3", HB_TAG('f', 'i', 'n', '3'));
+	_insert_feature("terminal_forms", HB_TAG('f', 'i', 'n', 'a'));
+	_insert_feature("flattened_accent_forms", HB_TAG('f', 'l', 'a', 'c'));
+	_insert_feature("fractions", HB_TAG('f', 'r', 'a', 'c'));
+	_insert_feature("full_widths", HB_TAG('f', 'w', 'i', 'd'));
+	_insert_feature("half_forms", HB_TAG('h', 'a', 'l', 'f'));
+	_insert_feature("halant_forms", HB_TAG('h', 'a', 'l', 'n'));
+	_insert_feature("alternate_half_widths", HB_TAG('h', 'a', 'l', 't'));
+	_insert_feature("historical_forms", HB_TAG('h', 'i', 's', 't'));
+	_insert_feature("horizontal_kana_alternates", HB_TAG('h', 'k', 'n', 'a'));
+	_insert_feature("historical_ligatures", HB_TAG('h', 'l', 'i', 'g'));
+	_insert_feature("hangul", HB_TAG('h', 'n', 'g', 'l'));
+	_insert_feature("hojo_kanji_forms", HB_TAG('h', 'o', 'j', 'o'));
+	_insert_feature("half_widths", HB_TAG('h', 'w', 'i', 'd'));
+	_insert_feature("initial_forms", HB_TAG('i', 'n', 'i', 't'));
+	_insert_feature("isolated_forms", HB_TAG('i', 's', 'o', 'l'));
+	_insert_feature("italics", HB_TAG('i', 't', 'a', 'l'));
+	_insert_feature("justification_alternates", HB_TAG('j', 'a', 'l', 't'));
+	_insert_feature("jis78_forms", HB_TAG('j', 'p', '7', '8'));
+	_insert_feature("jis83_forms", HB_TAG('j', 'p', '8', '3'));
+	_insert_feature("jis90_forms", HB_TAG('j', 'p', '9', '0'));
+	_insert_feature("jis2004_forms", HB_TAG('j', 'p', '0', '4'));
+	_insert_feature("kerning", HB_TAG('k', 'e', 'r', 'n'));
+	_insert_feature("left_bounds", HB_TAG('l', 'f', 'b', 'd'));
+	_insert_feature("standard_ligatures", HB_TAG('l', 'i', 'g', 'a'));
+	_insert_feature("leading_jamo_forms", HB_TAG('l', 'j', 'm', 'o'));
+	_insert_feature("lining_figures", HB_TAG('l', 'n', 'u', 'm'));
+	_insert_feature("localized_forms", HB_TAG('l', 'o', 'c', 'l'));
+	_insert_feature("left_to_right_alternates", HB_TAG('l', 't', 'r', 'a'));
+	_insert_feature("left_to_right_mirrored_forms", HB_TAG('l', 't', 'r', 'm'));
+	_insert_feature("mark_positioning", HB_TAG('m', 'a', 'r', 'k'));
+	_insert_feature("medial_forms_2", HB_TAG('m', 'e', 'd', '2'));
+	_insert_feature("medial_forms", HB_TAG('m', 'e', 'd', 'i'));
+	_insert_feature("mathematical_greek", HB_TAG('m', 'g', 'r', 'k'));
+	_insert_feature("mark_to_mark_positioning", HB_TAG('m', 'k', 'm', 'k'));
+	_insert_feature("mark_positioning_via_substitution", HB_TAG('m', 's', 'e', 't'));
+	_insert_feature("alternate_annotation_forms", HB_TAG('n', 'a', 'l', 't'));
+	_insert_feature("nlc_kanji_forms", HB_TAG('n', 'l', 'c', 'k'));
+	_insert_feature("nukta_forms", HB_TAG('n', 'u', 'k', 't'));
+	_insert_feature("numerators", HB_TAG('n', 'u', 'm', 'r'));
+	_insert_feature("oldstyle_figures", HB_TAG('o', 'n', 'u', 'm'));
+	_insert_feature("optical_bounds", HB_TAG('o', 'p', 'b', 'd'));
+	_insert_feature("ordinals", HB_TAG('o', 'r', 'd', 'n'));
+	_insert_feature("ornaments", HB_TAG('o', 'r', 'n', 'm'));
+	_insert_feature("proportional_alternate_widths", HB_TAG('p', 'a', 'l', 't'));
+	_insert_feature("petite_capitals", HB_TAG('p', 'c', 'a', 'p'));
+	_insert_feature("proportional_kana", HB_TAG('p', 'k', 'n', 'a'));
+	_insert_feature("proportional_figures", HB_TAG('p', 'n', 'u', 'm'));
+	_insert_feature("pre_base_forms", HB_TAG('p', 'r', 'e', 'f'));
+	_insert_feature("pre_base_substitutions", HB_TAG('p', 'r', 'e', 's'));
+	_insert_feature("post_base_forms", HB_TAG('p', 's', 't', 'f'));
+	_insert_feature("post_base_substitutions", HB_TAG('p', 's', 't', 's'));
+	_insert_feature("proportional_widths", HB_TAG('p', 'w', 'i', 'd'));
+	_insert_feature("quarter_widths", HB_TAG('q', 'w', 'i', 'd'));
+	_insert_feature("randomize", HB_TAG('r', 'a', 'n', 'd'));
+	_insert_feature("required_contextual_alternates", HB_TAG('r', 'c', 'l', 't'));
+	_insert_feature("rakar_forms", HB_TAG('r', 'k', 'r', 'f'));
+	_insert_feature("required_ligatures", HB_TAG('r', 'l', 'i', 'g'));
+	_insert_feature("reph_forms", HB_TAG('r', 'p', 'h', 'f'));
+	_insert_feature("right_bounds", HB_TAG('r', 't', 'b', 'd'));
+	_insert_feature("right_to_left_alternates", HB_TAG('r', 't', 'l', 'a'));
+	_insert_feature("right_to_left_mirrored_forms", HB_TAG('r', 't', 'l', 'm'));
+	_insert_feature("ruby_notation_forms", HB_TAG('r', 'u', 'b', 'y'));
+	_insert_feature("required_variation_alternates", HB_TAG('r', 'v', 'r', 'n'));
+	_insert_feature("stylistic_alternates", HB_TAG('s', 'a', 'l', 't'));
+	_insert_feature("scientific_inferiors", HB_TAG('s', 'i', 'n', 'f'));
+	_insert_feature("optical_size", HB_TAG('s', 'i', 'z', 'e'));
+	_insert_feature("small_capitals", HB_TAG('s', 'm', 'c', 'p'));
+	_insert_feature("simplified_forms", HB_TAG('s', 'm', 'p', 'l'));
+	_insert_feature("stylistic_set_01", HB_TAG('s', 's', '0', '1'));
+	_insert_feature("stylistic_set_02", HB_TAG('s', 's', '0', '2'));
+	_insert_feature("stylistic_set_03", HB_TAG('s', 's', '0', '3'));
+	_insert_feature("stylistic_set_04", HB_TAG('s', 's', '0', '4'));
+	_insert_feature("stylistic_set_05", HB_TAG('s', 's', '0', '5'));
+	_insert_feature("stylistic_set_06", HB_TAG('s', 's', '0', '6'));
+	_insert_feature("stylistic_set_07", HB_TAG('s', 's', '0', '7'));
+	_insert_feature("stylistic_set_08", HB_TAG('s', 's', '0', '8'));
+	_insert_feature("stylistic_set_09", HB_TAG('s', 's', '0', '9'));
+	_insert_feature("stylistic_set_10", HB_TAG('s', 's', '1', '0'));
+	_insert_feature("stylistic_set_11", HB_TAG('s', 's', '1', '1'));
+	_insert_feature("stylistic_set_12", HB_TAG('s', 's', '1', '2'));
+	_insert_feature("stylistic_set_13", HB_TAG('s', 's', '1', '3'));
+	_insert_feature("stylistic_set_14", HB_TAG('s', 's', '1', '4'));
+	_insert_feature("stylistic_set_15", HB_TAG('s', 's', '1', '5'));
+	_insert_feature("stylistic_set_16", HB_TAG('s', 's', '1', '6'));
+	_insert_feature("stylistic_set_17", HB_TAG('s', 's', '1', '7'));
+	_insert_feature("stylistic_set_18", HB_TAG('s', 's', '1', '8'));
+	_insert_feature("stylistic_set_19", HB_TAG('s', 's', '1', '9'));
+	_insert_feature("stylistic_set_20", HB_TAG('s', 's', '2', '0'));
+	_insert_feature("math_script_style_alternates", HB_TAG('s', 's', 't', 'y'));
+	_insert_feature("stretching_glyph_decomposition", HB_TAG('s', 't', 'c', 'h'));
+	_insert_feature("subscript", HB_TAG('s', 'u', 'b', 's'));
+	_insert_feature("superscript", HB_TAG('s', 'u', 'p', 's'));
+	_insert_feature("swash", HB_TAG('s', 'w', 's', 'h'));
+	_insert_feature("titling", HB_TAG('t', 'i', 't', 'l'));
+	_insert_feature("trailing_jamo_forms", HB_TAG('t', 'j', 'm', 'o'));
+	_insert_feature("traditional_name_forms", HB_TAG('t', 'n', 'a', 'm'));
+	_insert_feature("tabular_figures", HB_TAG('t', 'n', 'u', 'm'));
+	_insert_feature("traditional_forms", HB_TAG('t', 'r', 'a', 'd'));
+	_insert_feature("third_widths", HB_TAG('t', 'w', 'i', 'd'));
+	_insert_feature("unicase", HB_TAG('u', 'n', 'i', 'c'));
+	_insert_feature("alternate_vertical_metrics", HB_TAG('v', 'a', 'l', 't'));
+	_insert_feature("vattu_variants", HB_TAG('v', 'a', 't', 'u'));
+	_insert_feature("vertical_writing", HB_TAG('v', 'e', 'r', 't'));
+	_insert_feature("alternate_vertical_half_metrics", HB_TAG('v', 'h', 'a', 'l'));
+	_insert_feature("vowel_jamo_forms", HB_TAG('v', 'j', 'm', 'o'));
+	_insert_feature("vertical_kana_alternates", HB_TAG('v', 'k', 'n', 'a'));
+	_insert_feature("vertical_kerning", HB_TAG('v', 'k', 'r', 'n'));
+	_insert_feature("proportional_alternate_vertical_metrics", HB_TAG('v', 'p', 'a', 'l'));
+	_insert_feature("vertical_alternates_and_rotation", HB_TAG('v', 'r', 't', '2'));
+	_insert_feature("vertical_alternates_for_rotation", HB_TAG('v', 'r', 't', 'r'));
+	_insert_feature("slashed_zero", HB_TAG('z', 'e', 'r', 'o'));
+
 	// Registered OpenType variation tag.
-	feature_sets.insert("italic", HB_TAG('i', 't', 'a', 'l'));
-	feature_sets.insert("optical_size", HB_TAG('o', 'p', 's', 'z'));
-	feature_sets.insert("slant", HB_TAG('s', 'l', 'n', 't'));
-	feature_sets.insert("width", HB_TAG('w', 'd', 't', 'h'));
-	feature_sets.insert("weight", HB_TAG('w', 'g', 'h', 't'));
+	_insert_feature("italic", HB_TAG('i', 't', 'a', 'l'));
+	_insert_feature("optical_size", HB_TAG('o', 'p', 's', 'z'));
+	_insert_feature("slant", HB_TAG('s', 'l', 'n', 't'));
+	_insert_feature("width", HB_TAG('w', 'd', 't', 'h'));
+	_insert_feature("weight", HB_TAG('w', 'g', 'h', 't'));
 }
 
-int32_t TextServerAdvanced::name_to_tag(const String &p_name) const {
+int64_t TextServerAdvanced::name_to_tag(const String &p_name) const {
 	if (feature_sets.has(p_name)) {
 		return feature_sets[p_name];
 	}
@@ -686,11 +742,9 @@ int32_t TextServerAdvanced::name_to_tag(const String &p_name) const {
 	return hb_tag_from_string(p_name.replace("custom_", "").ascii().get_data(), -1);
 }
 
-String TextServerAdvanced::tag_to_name(int32_t p_tag) const {
-	for (const KeyValue<StringName, int32_t> &E : feature_sets) {
-		if (E.value == p_tag) {
-			return E.key;
-		}
+String TextServerAdvanced::tag_to_name(int64_t p_tag) const {
+	if (feature_sets_inv.has(p_tag)) {
+		return feature_sets_inv[p_tag];
 	}
 
 	// No readable name, use tag string.
@@ -728,7 +782,7 @@ _FORCE_INLINE_ TextServerAdvanced::FontTexturePosition TextServerAdvanced::find_
 			continue;
 		}
 
-		ret.y = 0x7FFFFFFF;
+		ret.y = 0x7fffffff;
 		ret.x = 0;
 
 		for (int j = 0; j < ct.texture_w - mw; j++) {
@@ -747,7 +801,7 @@ _FORCE_INLINE_ TextServerAdvanced::FontTexturePosition TextServerAdvanced::find_
 			}
 		}
 
-		if (ret.y == 0x7FFFFFFF || ret.y + mh > ct.texture_h) {
+		if (ret.y == 0x7fffffff || ret.y + mh > ct.texture_h) {
 			continue; // Fail, could not fit it here.
 		}
 
@@ -768,7 +822,11 @@ _FORCE_INLINE_ TextServerAdvanced::FontTexturePosition TextServerAdvanced::find_
 			texsize = mh; // Special case, adapt to it?
 		}
 
+#ifdef GDEXTENSION
+		texsize = Math::next_power_of_2(texsize);
+#else
 		texsize = next_power_of_2(texsize);
+#endif
 		if (p_msdf) {
 			texsize = MIN(texsize, 2048);
 		} else {
@@ -804,8 +862,9 @@ _FORCE_INLINE_ TextServerAdvanced::FontTexturePosition TextServerAdvanced::find_
 			}
 		}
 		tex.offsets.resize(texsize);
+		int32_t *offw = tex.offsets.ptrw();
 		for (int i = 0; i < texsize; i++) { // Zero offsets.
-			tex.offsets.write[i] = 0;
+			offw[i] = 0;
 		}
 
 		p_data->textures.push_back(tex);
@@ -983,7 +1042,9 @@ _FORCE_INLINE_ TextServerAdvanced::FontGlyph TextServerAdvanced::rasterize_msdf(
 		// Blit to image and texture.
 		{
 			if (RenderingServer::get_singleton() != nullptr) {
-				Ref<Image> img = memnew(Image(tex.texture_w, tex.texture_h, 0, Image::FORMAT_RGBA8, tex.imgdata));
+				Ref<Image> img;
+				img.instantiate();
+				img->create_from_data(tex.texture_w, tex.texture_h, 0, Image::FORMAT_RGBA8, tex.imgdata);
 				if (tex.texture.is_null()) {
 					tex.texture.instantiate();
 					tex.texture->create_from_image(img);
@@ -994,8 +1055,9 @@ _FORCE_INLINE_ TextServerAdvanced::FontGlyph TextServerAdvanced::rasterize_msdf(
 		}
 
 		// Update height array.
+		int32_t *offw = tex.offsets.ptrw();
 		for (int k = tex_pos.x; k < tex_pos.x + mw; k++) {
-			tex.offsets.write[k] = tex_pos.y + mh;
+			offw[k] = tex_pos.y + mh;
 		}
 
 		chr.texture_idx = tex_pos.index;
@@ -1055,7 +1117,7 @@ _FORCE_INLINE_ TextServerAdvanced::FontGlyph TextServerAdvanced::rasterize_bitma
 						wr[ofs + 3] = bitmap.buffer[ofs_color + 3];
 					} break;
 					default:
-						ERR_FAIL_V_MSG(FontGlyph(), "Font uses unsupported pixel format: " + itos(bitmap.pixel_mode) + ".");
+						ERR_FAIL_V_MSG(FontGlyph(), "Font uses unsupported pixel format: " + String::num_int64(bitmap.pixel_mode) + ".");
 						break;
 				}
 			}
@@ -1065,7 +1127,9 @@ _FORCE_INLINE_ TextServerAdvanced::FontGlyph TextServerAdvanced::rasterize_bitma
 	// Blit to image and texture.
 	{
 		if (RenderingServer::get_singleton() != nullptr) {
-			Ref<Image> img = memnew(Image(tex.texture_w, tex.texture_h, 0, require_format, tex.imgdata));
+			Ref<Image> img;
+			img.instantiate();
+			img->create_from_data(tex.texture_w, tex.texture_h, 0, require_format, tex.imgdata);
 
 			if (tex.texture.is_null()) {
 				tex.texture.instantiate();
@@ -1077,8 +1141,9 @@ _FORCE_INLINE_ TextServerAdvanced::FontGlyph TextServerAdvanced::rasterize_bitma
 	}
 
 	// Update height array.
+	int32_t *offw = tex.offsets.ptrw();
 	for (int k = tex_pos.x; k < tex_pos.x + mw; k++) {
-		tex.offsets.write[k] = tex_pos.y + mh;
+		offw[k] = tex_pos.y + mh;
 	}
 
 	FontGlyph chr;
@@ -1100,7 +1165,7 @@ _FORCE_INLINE_ TextServerAdvanced::FontGlyph TextServerAdvanced::rasterize_bitma
 _FORCE_INLINE_ bool TextServerAdvanced::_ensure_glyph(FontDataAdvanced *p_font_data, const Vector2i &p_size, int32_t p_glyph) const {
 	ERR_FAIL_COND_V(!_ensure_cache_for_size(p_font_data, p_size), false);
 
-	int32_t glyph_index = p_glyph & 0xFFFFFF; // Remove subpixel shifts.
+	int32_t glyph_index = p_glyph & 0xffffff; // Remove subpixel shifts.
 
 	FontDataForSizeAdvanced *fd = p_font_data->cache[p_size];
 	if (fd->glyph_map.has(p_glyph)) {
@@ -1187,7 +1252,7 @@ _FORCE_INLINE_ bool TextServerAdvanced::_ensure_glyph(FontDataAdvanced *p_font_d
 			}
 		} else {
 			FT_Stroker stroker;
-			if (FT_Stroker_New(library, &stroker) != 0) {
+			if (FT_Stroker_New(ft_library, &stroker) != 0) {
 				fd->glyph_map[p_glyph] = FontGlyph();
 				ERR_FAIL_V_MSG(false, "FreeType: Failed to load glyph stroker.");
 			}
@@ -1233,8 +1298,8 @@ _FORCE_INLINE_ bool TextServerAdvanced::_ensure_cache_for_size(FontDataAdvanced
 		// Init dynamic font.
 #ifdef MODULE_FREETYPE_ENABLED
 		int error = 0;
-		if (!library) {
-			error = FT_Init_FreeType(&library);
+		if (!ft_library) {
+			error = FT_Init_FreeType(&ft_library);
 			ERR_FAIL_COND_V_MSG(error != 0, false, "FreeType: Error initializing library: '" + String(FT_Error_String(error)) + "'.");
 		}
 
@@ -1249,7 +1314,7 @@ _FORCE_INLINE_ bool TextServerAdvanced::_ensure_cache_for_size(FontDataAdvanced
 		fargs.memory_size = p_font_data->data_size;
 		fargs.flags = FT_OPEN_MEMORY;
 		fargs.stream = &fd->stream;
-		error = FT_Open_Face(library, &fargs, 0, &fd->face);
+		error = FT_Open_Face(ft_library, &fargs, 0, &fd->face);
 		if (error) {
 			FT_Done_Face(fd->face);
 			fd->face = nullptr;
@@ -1257,9 +1322,9 @@ _FORCE_INLINE_ bool TextServerAdvanced::_ensure_cache_for_size(FontDataAdvanced
 		}
 
 		if (p_font_data->msdf) {
-			fd->oversampling = 1.0f;
+			fd->oversampling = 1.0;
 			fd->size.x = p_font_data->msdf_source_size;
-		} else if (p_font_data->oversampling <= 0.0f) {
+		} else if (p_font_data->oversampling <= 0.0) {
 			fd->oversampling = font_get_global_oversampling();
 		} else {
 			fd->oversampling = p_font_data->oversampling;
@@ -1268,19 +1333,19 @@ _FORCE_INLINE_ bool TextServerAdvanced::_ensure_cache_for_size(FontDataAdvanced
 		if (FT_HAS_COLOR(fd->face) && fd->face->num_fixed_sizes > 0) {
 			int best_match = 0;
 			int diff = ABS(fd->size.x - ((int64_t)fd->face->available_sizes[0].width));
-			fd->scale = float(fd->size.x * fd->oversampling) / fd->face->available_sizes[0].width;
+			fd->scale = double(fd->size.x * fd->oversampling) / fd->face->available_sizes[0].width;
 			for (int i = 1; i < fd->face->num_fixed_sizes; i++) {
 				int ndiff = ABS(fd->size.x - ((int64_t)fd->face->available_sizes[i].width));
 				if (ndiff < diff) {
 					best_match = i;
 					diff = ndiff;
-					fd->scale = float(fd->size.x * fd->oversampling) / fd->face->available_sizes[i].width;
+					fd->scale = double(fd->size.x * fd->oversampling) / fd->face->available_sizes[i].width;
 				}
 			}
 			FT_Select_Size(fd->face, best_match);
 		} else {
-			FT_Set_Pixel_Sizes(fd->face, 0, float(fd->size.x * fd->oversampling));
-			fd->scale = ((float)fd->size.x * fd->oversampling) / (float)fd->face->size->metrics.y_ppem;
+			FT_Set_Pixel_Sizes(fd->face, 0, double(fd->size.x * fd->oversampling));
+			fd->scale = ((double)fd->size.x * fd->oversampling) / (double)fd->face->size->metrics.y_ppem;
 		}
 
 		fd->hb_handle = hb_ft_font_create(fd->face, nullptr);
@@ -1573,7 +1638,7 @@ _FORCE_INLINE_ bool TextServerAdvanced::_ensure_cache_for_size(FontDataAdvanced
 				for (FT_UInt i = 0; i < amaster->num_axis; i++) {
 					p_font_data->supported_varaitions[(int32_t)amaster->axis[i].tag] = Vector3i(amaster->axis[i].minimum / 65536, amaster->axis[i].maximum / 65536, amaster->axis[i].def / 65536);
 				}
-				FT_Done_MM_Var(library, amaster);
+				FT_Done_MM_Var(ft_library, amaster);
 			}
 			p_font_data->face_init = true;
 		}
@@ -1595,17 +1660,17 @@ _FORCE_INLINE_ bool TextServerAdvanced::_ensure_cache_for_size(FontDataAdvanced
 
 				// Reset to default.
 				var.tag = amaster->axis[i].tag;
-				var.value = (double)amaster->axis[i].def / 65536.f;
+				var.value = (double)amaster->axis[i].def / 65536.0;
 				coords.write[i] = amaster->axis[i].def;
 
 				if (p_font_data->variation_coordinates.has(var.tag)) {
 					var.value = p_font_data->variation_coordinates[var.tag];
-					coords.write[i] = CLAMP(var.value * 65536.f, amaster->axis[i].minimum, amaster->axis[i].maximum);
+					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)];
-					coords.write[i] = CLAMP(var.value * 65536.f, amaster->axis[i].minimum, amaster->axis[i].maximum);
+					coords.write[i] = CLAMP(var.value * 65536.0, amaster->axis[i].minimum, amaster->axis[i].maximum);
 				}
 
 				hb_vars.push_back(var);
@@ -1613,7 +1678,7 @@ _FORCE_INLINE_ bool TextServerAdvanced::_ensure_cache_for_size(FontDataAdvanced
 
 			FT_Set_Var_Design_Coordinates(fd->face, coords.size(), coords.ptrw());
 			hb_font_set_variations(fd->hb_handle, hb_vars.is_empty() ? nullptr : &hb_vars[0], hb_vars.size());
-			FT_Done_MM_Var(library, amaster);
+			FT_Done_MM_Var(ft_library, amaster);
 		}
 #else
 		ERR_FAIL_V_MSG(false, "FreeType: Can't load dynamic font, engine is compiled without FreeType support!");
@@ -1637,7 +1702,7 @@ _FORCE_INLINE_ void TextServerAdvanced::_font_clear_cache(FontDataAdvanced *p_fo
 	p_font_data->supported_scripts.clear();
 }
 
-hb_font_t *TextServerAdvanced::_font_get_hb_handle(RID p_font_rid, int p_size) const {
+hb_font_t *TextServerAdvanced::_font_get_hb_handle(const RID &p_font_rid, int64_t p_size) const {
 	FontDataAdvanced *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND_V(!fd, nullptr);
 
@@ -1655,7 +1720,7 @@ RID TextServerAdvanced::create_font() {
 	return font_owner.make_rid(fd);
 }
 
-void TextServerAdvanced::font_set_data(RID p_font_rid, const PackedByteArray &p_data) {
+void TextServerAdvanced::font_set_data(const RID &p_font_rid, const PackedByteArray &p_data) {
 	FontDataAdvanced *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND(!fd);
 
@@ -1666,18 +1731,18 @@ void TextServerAdvanced::font_set_data(RID p_font_rid, const PackedByteArray &p_
 	fd->data_size = fd->data.size();
 }
 
-void TextServerAdvanced::font_set_data_ptr(RID p_font_rid, const uint8_t *p_data_ptr, size_t p_data_size) {
+void TextServerAdvanced::font_set_data_ptr(const RID &p_font_rid, const uint8_t *p_data_ptr, int64_t p_data_size) {
 	FontDataAdvanced *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND(!fd);
 
 	MutexLock lock(fd->mutex);
 	_font_clear_cache(fd);
-	fd->data.clear();
+	fd->data.resize(0);
 	fd->data_ptr = p_data_ptr;
 	fd->data_size = p_data_size;
 }
 
-void TextServerAdvanced::font_set_style(RID p_font_rid, uint32_t /*FontStyle*/ p_style) {
+void TextServerAdvanced::font_set_style(const RID &p_font_rid, int64_t /*FontStyle*/ p_style) {
 	FontDataAdvanced *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND(!fd);
 
@@ -1687,7 +1752,7 @@ void TextServerAdvanced::font_set_style(RID p_font_rid, uint32_t /*FontStyle*/ p
 	fd->style_flags = p_style;
 }
 
-uint32_t /*FontStyle*/ TextServerAdvanced::font_get_style(RID p_font_rid) const {
+int64_t /*FontStyle*/ TextServerAdvanced::font_get_style(const RID &p_font_rid) const {
 	FontDataAdvanced *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND_V(!fd, 0);
 
@@ -1697,7 +1762,7 @@ uint32_t /*FontStyle*/ TextServerAdvanced::font_get_style(RID p_font_rid) const
 	return fd->style_flags;
 }
 
-void TextServerAdvanced::font_set_style_name(RID p_font_rid, const String &p_name) {
+void TextServerAdvanced::font_set_style_name(const RID &p_font_rid, const String &p_name) {
 	FontDataAdvanced *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND(!fd);
 
@@ -1707,7 +1772,7 @@ void TextServerAdvanced::font_set_style_name(RID p_font_rid, const String &p_nam
 	fd->style_name = p_name;
 }
 
-String TextServerAdvanced::font_get_style_name(RID p_font_rid) const {
+String TextServerAdvanced::font_get_style_name(const RID &p_font_rid) const {
 	FontDataAdvanced *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND_V(!fd, String());
 
@@ -1717,7 +1782,7 @@ String TextServerAdvanced::font_get_style_name(RID p_font_rid) const {
 	return fd->style_name;
 }
 
-void TextServerAdvanced::font_set_name(RID p_font_rid, const String &p_name) {
+void TextServerAdvanced::font_set_name(const RID &p_font_rid, const String &p_name) {
 	FontDataAdvanced *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND(!fd);
 
@@ -1727,7 +1792,7 @@ void TextServerAdvanced::font_set_name(RID p_font_rid, const String &p_name) {
 	fd->font_name = p_name;
 }
 
-String TextServerAdvanced::font_get_name(RID p_font_rid) const {
+String TextServerAdvanced::font_get_name(const RID &p_font_rid) const {
 	FontDataAdvanced *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND_V(!fd, String());
 
@@ -1737,7 +1802,7 @@ String TextServerAdvanced::font_get_name(RID p_font_rid) const {
 	return fd->font_name;
 }
 
-void TextServerAdvanced::font_set_antialiased(RID p_font_rid, bool p_antialiased) {
+void TextServerAdvanced::font_set_antialiased(const RID &p_font_rid, bool p_antialiased) {
 	FontDataAdvanced *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND(!fd);
 
@@ -1748,7 +1813,7 @@ void TextServerAdvanced::font_set_antialiased(RID p_font_rid, bool p_antialiased
 	}
 }
 
-bool TextServerAdvanced::font_is_antialiased(RID p_font_rid) const {
+bool TextServerAdvanced::font_is_antialiased(const RID &p_font_rid) const {
 	FontDataAdvanced *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND_V(!fd, false);
 
@@ -1756,7 +1821,7 @@ bool TextServerAdvanced::font_is_antialiased(RID p_font_rid) const {
 	return fd->antialiased;
 }
 
-void TextServerAdvanced::font_set_multichannel_signed_distance_field(RID p_font_rid, bool p_msdf) {
+void TextServerAdvanced::font_set_multichannel_signed_distance_field(const RID &p_font_rid, bool p_msdf) {
 	FontDataAdvanced *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND(!fd);
 
@@ -1767,7 +1832,7 @@ void TextServerAdvanced::font_set_multichannel_signed_distance_field(RID p_font_
 	}
 }
 
-bool TextServerAdvanced::font_is_multichannel_signed_distance_field(RID p_font_rid) const {
+bool TextServerAdvanced::font_is_multichannel_signed_distance_field(const RID &p_font_rid) const {
 	FontDataAdvanced *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND_V(!fd, false);
 
@@ -1775,7 +1840,7 @@ bool TextServerAdvanced::font_is_multichannel_signed_distance_field(RID p_font_r
 	return fd->msdf;
 }
 
-void TextServerAdvanced::font_set_msdf_pixel_range(RID p_font_rid, int p_msdf_pixel_range) {
+void TextServerAdvanced::font_set_msdf_pixel_range(const RID &p_font_rid, int64_t p_msdf_pixel_range) {
 	FontDataAdvanced *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND(!fd);
 
@@ -1786,7 +1851,7 @@ void TextServerAdvanced::font_set_msdf_pixel_range(RID p_font_rid, int p_msdf_pi
 	}
 }
 
-int TextServerAdvanced::font_get_msdf_pixel_range(RID p_font_rid) const {
+int64_t TextServerAdvanced::font_get_msdf_pixel_range(const RID &p_font_rid) const {
 	FontDataAdvanced *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND_V(!fd, false);
 
@@ -1794,7 +1859,7 @@ int TextServerAdvanced::font_get_msdf_pixel_range(RID p_font_rid) const {
 	return fd->msdf_range;
 }
 
-void TextServerAdvanced::font_set_msdf_size(RID p_font_rid, int p_msdf_size) {
+void TextServerAdvanced::font_set_msdf_size(const RID &p_font_rid, int64_t p_msdf_size) {
 	FontDataAdvanced *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND(!fd);
 
@@ -1805,7 +1870,7 @@ void TextServerAdvanced::font_set_msdf_size(RID p_font_rid, int p_msdf_size) {
 	}
 }
 
-int TextServerAdvanced::font_get_msdf_size(RID p_font_rid) const {
+int64_t TextServerAdvanced::font_get_msdf_size(const RID &p_font_rid) const {
 	FontDataAdvanced *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND_V(!fd, false);
 
@@ -1813,7 +1878,7 @@ int TextServerAdvanced::font_get_msdf_size(RID p_font_rid) const {
 	return fd->msdf_source_size;
 }
 
-void TextServerAdvanced::font_set_fixed_size(RID p_font_rid, int p_fixed_size) {
+void TextServerAdvanced::font_set_fixed_size(const RID &p_font_rid, int64_t p_fixed_size) {
 	FontDataAdvanced *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND(!fd);
 
@@ -1823,7 +1888,7 @@ void TextServerAdvanced::font_set_fixed_size(RID p_font_rid, int p_fixed_size) {
 	}
 }
 
-int TextServerAdvanced::font_get_fixed_size(RID p_font_rid) const {
+int64_t TextServerAdvanced::font_get_fixed_size(const RID &p_font_rid) const {
 	FontDataAdvanced *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND_V(!fd, false);
 
@@ -1831,7 +1896,7 @@ int TextServerAdvanced::font_get_fixed_size(RID p_font_rid) const {
 	return fd->fixed_size;
 }
 
-void TextServerAdvanced::font_set_force_autohinter(RID p_font_rid, bool p_force_autohinter) {
+void TextServerAdvanced::font_set_force_autohinter(const RID &p_font_rid, bool p_force_autohinter) {
 	FontDataAdvanced *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND(!fd);
 
@@ -1842,7 +1907,7 @@ void TextServerAdvanced::font_set_force_autohinter(RID p_font_rid, bool p_force_
 	}
 }
 
-bool TextServerAdvanced::font_is_force_autohinter(RID p_font_rid) const {
+bool TextServerAdvanced::font_is_force_autohinter(const RID &p_font_rid) const {
 	FontDataAdvanced *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND_V(!fd, false);
 
@@ -1850,7 +1915,7 @@ bool TextServerAdvanced::font_is_force_autohinter(RID p_font_rid) const {
 	return fd->force_autohinter;
 }
 
-void TextServerAdvanced::font_set_hinting(RID p_font_rid, TextServer::Hinting p_hinting) {
+void TextServerAdvanced::font_set_hinting(const RID &p_font_rid, TextServer::Hinting p_hinting) {
 	FontDataAdvanced *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND(!fd);
 
@@ -1861,7 +1926,7 @@ void TextServerAdvanced::font_set_hinting(RID p_font_rid, TextServer::Hinting p_
 	}
 }
 
-TextServer::Hinting TextServerAdvanced::font_get_hinting(RID p_font_rid) const {
+TextServer::Hinting TextServerAdvanced::font_get_hinting(const RID &p_font_rid) const {
 	FontDataAdvanced *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND_V(!fd, HINTING_NONE);
 
@@ -1869,7 +1934,7 @@ TextServer::Hinting TextServerAdvanced::font_get_hinting(RID p_font_rid) const {
 	return fd->hinting;
 }
 
-void TextServerAdvanced::font_set_subpixel_positioning(RID p_font_rid, TextServer::SubpixelPositioning p_subpixel) {
+void TextServerAdvanced::font_set_subpixel_positioning(const RID &p_font_rid, TextServer::SubpixelPositioning p_subpixel) {
 	FontDataAdvanced *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND(!fd);
 
@@ -1879,7 +1944,7 @@ void TextServerAdvanced::font_set_subpixel_positioning(RID p_font_rid, TextServe
 	}
 }
 
-TextServer::SubpixelPositioning TextServerAdvanced::font_get_subpixel_positioning(RID p_font_rid) const {
+TextServer::SubpixelPositioning TextServerAdvanced::font_get_subpixel_positioning(const RID &p_font_rid) const {
 	FontDataAdvanced *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND_V(!fd, SUBPIXEL_POSITIONING_DISABLED);
 
@@ -1887,7 +1952,7 @@ TextServer::SubpixelPositioning TextServerAdvanced::font_get_subpixel_positionin
 	return fd->subpixel_positioning;
 }
 
-void TextServerAdvanced::font_set_embolden(RID p_font_rid, float p_strength) {
+void TextServerAdvanced::font_set_embolden(const RID &p_font_rid, double p_strength) {
 	FontDataAdvanced *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND(!fd);
 
@@ -1898,15 +1963,15 @@ void TextServerAdvanced::font_set_embolden(RID p_font_rid, float p_strength) {
 	}
 }
 
-float TextServerAdvanced::font_get_embolden(RID p_font_rid) const {
+double TextServerAdvanced::font_get_embolden(const RID &p_font_rid) const {
 	FontDataAdvanced *fd = font_owner.get_or_null(p_font_rid);
-	ERR_FAIL_COND_V(!fd, 0.f);
+	ERR_FAIL_COND_V(!fd, 0.0);
 
 	MutexLock lock(fd->mutex);
 	return fd->embolden;
 }
 
-void TextServerAdvanced::font_set_transform(RID p_font_rid, Transform2D p_transform) {
+void TextServerAdvanced::font_set_transform(const RID &p_font_rid, const Transform2D &p_transform) {
 	FontDataAdvanced *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND(!fd);
 
@@ -1917,7 +1982,7 @@ void TextServerAdvanced::font_set_transform(RID p_font_rid, Transform2D p_transf
 	}
 }
 
-Transform2D TextServerAdvanced::font_get_transform(RID p_font_rid) const {
+Transform2D TextServerAdvanced::font_get_transform(const RID &p_font_rid) const {
 	FontDataAdvanced *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND_V(!fd, Transform2D());
 
@@ -1925,7 +1990,7 @@ Transform2D TextServerAdvanced::font_get_transform(RID p_font_rid) const {
 	return fd->transform;
 }
 
-void TextServerAdvanced::font_set_variation_coordinates(RID p_font_rid, const Dictionary &p_variation_coordinates) {
+void TextServerAdvanced::font_set_variation_coordinates(const RID &p_font_rid, const Dictionary &p_variation_coordinates) {
 	FontDataAdvanced *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND(!fd);
 
@@ -1936,7 +2001,7 @@ void TextServerAdvanced::font_set_variation_coordinates(RID p_font_rid, const Di
 	}
 }
 
-Dictionary TextServerAdvanced::font_get_variation_coordinates(RID p_font_rid) const {
+Dictionary TextServerAdvanced::font_get_variation_coordinates(const RID &p_font_rid) const {
 	FontDataAdvanced *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND_V(!fd, Dictionary());
 
@@ -1944,7 +2009,7 @@ Dictionary TextServerAdvanced::font_get_variation_coordinates(RID p_font_rid) co
 	return fd->variation_coordinates;
 }
 
-void TextServerAdvanced::font_set_oversampling(RID p_font_rid, float p_oversampling) {
+void TextServerAdvanced::font_set_oversampling(const RID &p_font_rid, double p_oversampling) {
 	FontDataAdvanced *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND(!fd);
 
@@ -1955,27 +2020,27 @@ void TextServerAdvanced::font_set_oversampling(RID p_font_rid, float p_oversampl
 	}
 }
 
-float TextServerAdvanced::font_get_oversampling(RID p_font_rid) const {
+double TextServerAdvanced::font_get_oversampling(const RID &p_font_rid) const {
 	FontDataAdvanced *fd = font_owner.get_or_null(p_font_rid);
-	ERR_FAIL_COND_V(!fd, 0.f);
+	ERR_FAIL_COND_V(!fd, 0.0);
 
 	MutexLock lock(fd->mutex);
 	return fd->oversampling;
 }
 
-Array TextServerAdvanced::font_get_size_cache_list(RID p_font_rid) const {
+Array TextServerAdvanced::font_get_size_cache_list(const RID &p_font_rid) const {
 	FontDataAdvanced *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND_V(!fd, Array());
 
 	MutexLock lock(fd->mutex);
 	Array ret;
-	for (const Map<Vector2i, FontDataForSizeAdvanced *>::Element *E = fd->cache.front(); E; E = E->next()) {
-		ret.push_back(E->key());
+	for (const KeyValue<Vector2i, FontDataForSizeAdvanced *> &E : fd->cache) {
+		ret.push_back(E.key);
 	}
 	return ret;
 }
 
-void TextServerAdvanced::font_clear_size_cache(RID p_font_rid) {
+void TextServerAdvanced::font_clear_size_cache(const RID &p_font_rid) {
 	FontDataAdvanced *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND(!fd);
 
@@ -1986,7 +2051,7 @@ void TextServerAdvanced::font_clear_size_cache(RID p_font_rid) {
 	fd->cache.clear();
 }
 
-void TextServerAdvanced::font_remove_size_cache(RID p_font_rid, const Vector2i &p_size) {
+void TextServerAdvanced::font_remove_size_cache(const RID &p_font_rid, const Vector2i &p_size) {
 	FontDataAdvanced *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND(!fd);
 
@@ -1997,7 +2062,7 @@ void TextServerAdvanced::font_remove_size_cache(RID p_font_rid, const Vector2i &
 	}
 }
 
-void TextServerAdvanced::font_set_ascent(RID p_font_rid, int p_size, float p_ascent) {
+void TextServerAdvanced::font_set_ascent(const RID &p_font_rid, int64_t p_size, double p_ascent) {
 	FontDataAdvanced *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND(!fd);
 
@@ -2008,23 +2073,23 @@ void TextServerAdvanced::font_set_ascent(RID p_font_rid, int p_size, float p_asc
 	fd->cache[size]->ascent = p_ascent;
 }
 
-float TextServerAdvanced::font_get_ascent(RID p_font_rid, int p_size) const {
+double TextServerAdvanced::font_get_ascent(const RID &p_font_rid, int64_t p_size) const {
 	FontDataAdvanced *fd = font_owner.get_or_null(p_font_rid);
-	ERR_FAIL_COND_V(!fd, 0.f);
+	ERR_FAIL_COND_V(!fd, 0.0);
 
 	MutexLock lock(fd->mutex);
 	Vector2i size = _get_size(fd, p_size);
 
-	ERR_FAIL_COND_V(!_ensure_cache_for_size(fd, size), 0.f);
+	ERR_FAIL_COND_V(!_ensure_cache_for_size(fd, size), 0.0);
 
 	if (fd->msdf) {
-		return fd->cache[size]->ascent * (float)p_size / (float)fd->msdf_source_size;
+		return fd->cache[size]->ascent * (double)p_size / (double)fd->msdf_source_size;
 	} else {
 		return fd->cache[size]->ascent;
 	}
 }
 
-void TextServerAdvanced::font_set_descent(RID p_font_rid, int p_size, float p_descent) {
+void TextServerAdvanced::font_set_descent(const RID &p_font_rid, int64_t p_size, double p_descent) {
 	FontDataAdvanced *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND(!fd);
 
@@ -2034,23 +2099,23 @@ void TextServerAdvanced::font_set_descent(RID p_font_rid, int p_size, float p_de
 	fd->cache[size]->descent = p_descent;
 }
 
-float TextServerAdvanced::font_get_descent(RID p_font_rid, int p_size) const {
+double TextServerAdvanced::font_get_descent(const RID &p_font_rid, int64_t p_size) const {
 	FontDataAdvanced *fd = font_owner.get_or_null(p_font_rid);
-	ERR_FAIL_COND_V(!fd, 0.f);
+	ERR_FAIL_COND_V(!fd, 0.0);
 
 	MutexLock lock(fd->mutex);
 	Vector2i size = _get_size(fd, p_size);
 
-	ERR_FAIL_COND_V(!_ensure_cache_for_size(fd, size), 0.f);
+	ERR_FAIL_COND_V(!_ensure_cache_for_size(fd, size), 0.0);
 
 	if (fd->msdf) {
-		return fd->cache[size]->descent * (float)p_size / (float)fd->msdf_source_size;
+		return fd->cache[size]->descent * (double)p_size / (double)fd->msdf_source_size;
 	} else {
 		return fd->cache[size]->descent;
 	}
 }
 
-void TextServerAdvanced::font_set_underline_position(RID p_font_rid, int p_size, float p_underline_position) {
+void TextServerAdvanced::font_set_underline_position(const RID &p_font_rid, int64_t p_size, double p_underline_position) {
 	FontDataAdvanced *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND(!fd);
 
@@ -2061,23 +2126,23 @@ void TextServerAdvanced::font_set_underline_position(RID p_font_rid, int p_size,
 	fd->cache[size]->underline_position = p_underline_position;
 }
 
-float TextServerAdvanced::font_get_underline_position(RID p_font_rid, int p_size) const {
+double TextServerAdvanced::font_get_underline_position(const RID &p_font_rid, int64_t p_size) const {
 	FontDataAdvanced *fd = font_owner.get_or_null(p_font_rid);
-	ERR_FAIL_COND_V(!fd, 0.f);
+	ERR_FAIL_COND_V(!fd, 0.0);
 
 	MutexLock lock(fd->mutex);
 	Vector2i size = _get_size(fd, p_size);
 
-	ERR_FAIL_COND_V(!_ensure_cache_for_size(fd, size), 0.f);
+	ERR_FAIL_COND_V(!_ensure_cache_for_size(fd, size), 0.0);
 
 	if (fd->msdf) {
-		return fd->cache[size]->underline_position * (float)p_size / (float)fd->msdf_source_size;
+		return fd->cache[size]->underline_position * (double)p_size / (double)fd->msdf_source_size;
 	} else {
 		return fd->cache[size]->underline_position;
 	}
 }
 
-void TextServerAdvanced::font_set_underline_thickness(RID p_font_rid, int p_size, float p_underline_thickness) {
+void TextServerAdvanced::font_set_underline_thickness(const RID &p_font_rid, int64_t p_size, double p_underline_thickness) {
 	FontDataAdvanced *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND(!fd);
 
@@ -2088,23 +2153,23 @@ void TextServerAdvanced::font_set_underline_thickness(RID p_font_rid, int p_size
 	fd->cache[size]->underline_thickness = p_underline_thickness;
 }
 
-float TextServerAdvanced::font_get_underline_thickness(RID p_font_rid, int p_size) const {
+double TextServerAdvanced::font_get_underline_thickness(const RID &p_font_rid, int64_t p_size) const {
 	FontDataAdvanced *fd = font_owner.get_or_null(p_font_rid);
-	ERR_FAIL_COND_V(!fd, 0.f);
+	ERR_FAIL_COND_V(!fd, 0.0);
 
 	MutexLock lock(fd->mutex);
 	Vector2i size = _get_size(fd, p_size);
 
-	ERR_FAIL_COND_V(!_ensure_cache_for_size(fd, size), 0.f);
+	ERR_FAIL_COND_V(!_ensure_cache_for_size(fd, size), 0.0);
 
 	if (fd->msdf) {
-		return fd->cache[size]->underline_thickness * (float)p_size / (float)fd->msdf_source_size;
+		return fd->cache[size]->underline_thickness * (double)p_size / (double)fd->msdf_source_size;
 	} else {
 		return fd->cache[size]->underline_thickness;
 	}
 }
 
-void TextServerAdvanced::font_set_scale(RID p_font_rid, int p_size, float p_scale) {
+void TextServerAdvanced::font_set_scale(const RID &p_font_rid, int64_t p_size, double p_scale) {
 	FontDataAdvanced *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND(!fd);
 
@@ -2115,23 +2180,23 @@ void TextServerAdvanced::font_set_scale(RID p_font_rid, int p_size, float p_scal
 	fd->cache[size]->scale = p_scale;
 }
 
-float TextServerAdvanced::font_get_scale(RID p_font_rid, int p_size) const {
+double TextServerAdvanced::font_get_scale(const RID &p_font_rid, int64_t p_size) const {
 	FontDataAdvanced *fd = font_owner.get_or_null(p_font_rid);
-	ERR_FAIL_COND_V(!fd, 0.f);
+	ERR_FAIL_COND_V(!fd, 0.0);
 
 	MutexLock lock(fd->mutex);
 	Vector2i size = _get_size(fd, p_size);
 
-	ERR_FAIL_COND_V(!_ensure_cache_for_size(fd, size), 0.f);
+	ERR_FAIL_COND_V(!_ensure_cache_for_size(fd, size), 0.0);
 
 	if (fd->msdf) {
-		return fd->cache[size]->scale * (float)p_size / (float)fd->msdf_source_size;
+		return fd->cache[size]->scale * (double)p_size / (double)fd->msdf_source_size;
 	} else {
 		return fd->cache[size]->scale / fd->cache[size]->oversampling;
 	}
 }
 
-void TextServerAdvanced::font_set_spacing(RID p_font_rid, int p_size, TextServer::SpacingType p_spacing, int p_value) {
+void TextServerAdvanced::font_set_spacing(const RID &p_font_rid, int64_t p_size, TextServer::SpacingType p_spacing, int64_t p_value) {
 	FontDataAdvanced *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND(!fd);
 
@@ -2147,12 +2212,12 @@ void TextServerAdvanced::font_set_spacing(RID p_font_rid, int p_size, TextServer
 			fd->cache[size]->spacing_space = p_value;
 		} break;
 		default: {
-			ERR_FAIL_MSG("Invalid spacing type: " + itos(p_spacing));
+			ERR_FAIL_MSG("Invalid spacing type: " + String::num_int64(p_spacing));
 		} break;
 	}
 }
 
-int TextServerAdvanced::font_get_spacing(RID p_font_rid, int p_size, TextServer::SpacingType p_spacing) const {
+int64_t TextServerAdvanced::font_get_spacing(const RID &p_font_rid, int64_t p_size, TextServer::SpacingType p_spacing) const {
 	FontDataAdvanced *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND_V(!fd, 0);
 
@@ -2164,26 +2229,26 @@ int TextServerAdvanced::font_get_spacing(RID p_font_rid, int p_size, TextServer:
 	switch (p_spacing) {
 		case TextServer::SPACING_GLYPH: {
 			if (fd->msdf) {
-				return fd->cache[size]->spacing_glyph * (float)p_size / (float)fd->msdf_source_size;
+				return fd->cache[size]->spacing_glyph * (double)p_size / (double)fd->msdf_source_size;
 			} else {
 				return fd->cache[size]->spacing_glyph;
 			}
 		} break;
 		case TextServer::SPACING_SPACE: {
 			if (fd->msdf) {
-				return fd->cache[size]->spacing_space * (float)p_size / (float)fd->msdf_source_size;
+				return fd->cache[size]->spacing_space * (double)p_size / (double)fd->msdf_source_size;
 			} else {
 				return fd->cache[size]->spacing_space;
 			}
 		} break;
 		default: {
-			ERR_FAIL_V_MSG(0, "Invalid spacing type: " + itos(p_spacing));
+			ERR_FAIL_V_MSG(0, "Invalid spacing type: " + String::num_int64(p_spacing));
 		} break;
 	}
 	return 0;
 }
 
-int TextServerAdvanced::font_get_texture_count(RID p_font_rid, const Vector2i &p_size) const {
+int64_t TextServerAdvanced::font_get_texture_count(const RID &p_font_rid, const Vector2i &p_size) const {
 	FontDataAdvanced *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND_V(!fd, 0);
 
@@ -2195,7 +2260,7 @@ int TextServerAdvanced::font_get_texture_count(RID p_font_rid, const Vector2i &p
 	return fd->cache[size]->textures.size();
 }
 
-void TextServerAdvanced::font_clear_textures(RID p_font_rid, const Vector2i &p_size) {
+void TextServerAdvanced::font_clear_textures(const RID &p_font_rid, const Vector2i &p_size) {
 	FontDataAdvanced *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND(!fd);
 	MutexLock lock(fd->mutex);
@@ -2205,7 +2270,7 @@ void TextServerAdvanced::font_clear_textures(RID p_font_rid, const Vector2i &p_s
 	fd->cache[size]->textures.clear();
 }
 
-void TextServerAdvanced::font_remove_texture(RID p_font_rid, const Vector2i &p_size, int p_texture_index) {
+void TextServerAdvanced::font_remove_texture(const RID &p_font_rid, const Vector2i &p_size, int64_t p_texture_index) {
 	FontDataAdvanced *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND(!fd);
 
@@ -2217,7 +2282,7 @@ void TextServerAdvanced::font_remove_texture(RID p_font_rid, const Vector2i &p_s
 	fd->cache[size]->textures.remove_at(p_texture_index);
 }
 
-void TextServerAdvanced::font_set_texture_image(RID p_font_rid, const Vector2i &p_size, int p_texture_index, const Ref<Image> &p_image) {
+void TextServerAdvanced::font_set_texture_image(const RID &p_font_rid, const Vector2i &p_size, int64_t p_texture_index, const Ref<Image> &p_image) {
 	FontDataAdvanced *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND(!fd);
 	ERR_FAIL_COND(p_image.is_null());
@@ -2237,13 +2302,16 @@ void TextServerAdvanced::font_set_texture_image(RID p_font_rid, const Vector2i &
 	tex.texture_h = p_image->get_height();
 	tex.format = p_image->get_format();
 
-	Ref<Image> img = memnew(Image(tex.texture_w, tex.texture_h, 0, tex.format, tex.imgdata));
+	Ref<Image> img;
+	img.instantiate();
+	img->create_from_data(tex.texture_w, tex.texture_h, 0, tex.format, tex.imgdata);
+
 	tex.texture = Ref<ImageTexture>();
 	tex.texture.instantiate();
 	tex.texture->create_from_image(img);
 }
 
-Ref<Image> TextServerAdvanced::font_get_texture_image(RID p_font_rid, const Vector2i &p_size, int p_texture_index) const {
+Ref<Image> TextServerAdvanced::font_get_texture_image(const RID &p_font_rid, const Vector2i &p_size, int64_t p_texture_index) const {
 	FontDataAdvanced *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND_V(!fd, Ref<Image>());
 
@@ -2252,13 +2320,15 @@ Ref<Image> TextServerAdvanced::font_get_texture_image(RID p_font_rid, const Vect
 	ERR_FAIL_COND_V(!_ensure_cache_for_size(fd, size), Ref<Image>());
 	ERR_FAIL_INDEX_V(p_texture_index, fd->cache[size]->textures.size(), Ref<Image>());
 
-	const FontTexture &tex = fd->cache[size]->textures.write[p_texture_index];
-	Ref<Image> img = memnew(Image(tex.texture_w, tex.texture_h, 0, tex.format, tex.imgdata));
+	const FontTexture &tex = fd->cache[size]->textures[p_texture_index];
+	Ref<Image> img;
+	img.instantiate();
+	img->create_from_data(tex.texture_w, tex.texture_h, 0, tex.format, tex.imgdata);
 
 	return img;
 }
 
-void TextServerAdvanced::font_set_texture_offsets(RID p_font_rid, const Vector2i &p_size, int p_texture_index, const PackedInt32Array &p_offset) {
+void TextServerAdvanced::font_set_texture_offsets(const RID &p_font_rid, const Vector2i &p_size, int64_t p_texture_index, const PackedInt32Array &p_offset) {
 	FontDataAdvanced *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND(!fd);
 
@@ -2274,7 +2344,7 @@ void TextServerAdvanced::font_set_texture_offsets(RID p_font_rid, const Vector2i
 	tex.offsets = p_offset;
 }
 
-PackedInt32Array TextServerAdvanced::font_get_texture_offsets(RID p_font_rid, const Vector2i &p_size, int p_texture_index) const {
+PackedInt32Array TextServerAdvanced::font_get_texture_offsets(const RID &p_font_rid, const Vector2i &p_size, int64_t p_texture_index) const {
 	FontDataAdvanced *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND_V(!fd, PackedInt32Array());
 
@@ -2283,11 +2353,11 @@ PackedInt32Array TextServerAdvanced::font_get_texture_offsets(RID p_font_rid, co
 	ERR_FAIL_COND_V(!_ensure_cache_for_size(fd, size), PackedInt32Array());
 	ERR_FAIL_INDEX_V(p_texture_index, fd->cache[size]->textures.size(), PackedInt32Array());
 
-	const FontTexture &tex = fd->cache[size]->textures.write[p_texture_index];
+	const FontTexture &tex = fd->cache[size]->textures[p_texture_index];
 	return tex.offsets;
 }
 
-Array TextServerAdvanced::font_get_glyph_list(RID p_font_rid, const Vector2i &p_size) const {
+Array TextServerAdvanced::font_get_glyph_list(const RID &p_font_rid, const Vector2i &p_size) const {
 	FontDataAdvanced *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND_V(!fd, Array());
 
@@ -2304,7 +2374,7 @@ Array TextServerAdvanced::font_get_glyph_list(RID p_font_rid, const Vector2i &p_
 	return ret;
 }
 
-void TextServerAdvanced::font_clear_glyphs(RID p_font_rid, const Vector2i &p_size) {
+void TextServerAdvanced::font_clear_glyphs(const RID &p_font_rid, const Vector2i &p_size) {
 	FontDataAdvanced *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND(!fd);
 
@@ -2315,7 +2385,7 @@ void TextServerAdvanced::font_clear_glyphs(RID p_font_rid, const Vector2i &p_siz
 	fd->cache[size]->glyph_map.clear();
 }
 
-void TextServerAdvanced::font_remove_glyph(RID p_font_rid, const Vector2i &p_size, int32_t p_glyph) {
+void TextServerAdvanced::font_remove_glyph(const RID &p_font_rid, const Vector2i &p_size, int64_t p_glyph) {
 	FontDataAdvanced *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND(!fd);
 
@@ -2326,7 +2396,7 @@ void TextServerAdvanced::font_remove_glyph(RID p_font_rid, const Vector2i &p_siz
 	fd->cache[size]->glyph_map.erase(p_glyph);
 }
 
-float TextServerAdvanced::_get_extra_advance(RID p_font_rid, int p_font_size) const {
+double TextServerAdvanced::_get_extra_advance(RID p_font_rid, int p_font_size) const {
 	const FontDataAdvanced *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND_V(!fd, 0.0);
 
@@ -2334,13 +2404,13 @@ float TextServerAdvanced::_get_extra_advance(RID p_font_rid, int p_font_size) co
 	Vector2i size = _get_size(fd, p_font_size);
 
 	if (fd->embolden != 0.0) {
-		return fd->embolden * float(size.x) / 64.0;
+		return fd->embolden * double(size.x) / 64.0;
 	} else {
 		return 0.0;
 	}
 }
 
-Vector2 TextServerAdvanced::font_get_glyph_advance(RID p_font_rid, int p_size, int32_t p_glyph) const {
+Vector2 TextServerAdvanced::font_get_glyph_advance(const RID &p_font_rid, int64_t p_size, int64_t p_glyph) const {
 	FontDataAdvanced *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND_V(!fd, Vector2());
 
@@ -2356,11 +2426,11 @@ Vector2 TextServerAdvanced::font_get_glyph_advance(RID p_font_rid, int p_size, i
 
 	Vector2 ea;
 	if (fd->embolden != 0.0) {
-		ea.x = fd->embolden * float(size.x) / 64.0;
+		ea.x = fd->embolden * double(size.x) / 64.0;
 	}
 
 	if (fd->msdf) {
-		return (gl[p_glyph].advance + ea) * (float)p_size / (float)fd->msdf_source_size;
+		return (gl[p_glyph].advance + ea) * (double)p_size / (double)fd->msdf_source_size;
 	} else if ((fd->subpixel_positioning == SUBPIXEL_POSITIONING_DISABLED) || (fd->subpixel_positioning == SUBPIXEL_POSITIONING_AUTO && size.x > SUBPIXEL_POSITIONING_ONE_HALF_MAX_SIZE)) {
 		return (gl[p_glyph].advance + ea).round();
 	} else {
@@ -2368,7 +2438,7 @@ Vector2 TextServerAdvanced::font_get_glyph_advance(RID p_font_rid, int p_size, i
 	}
 }
 
-void TextServerAdvanced::font_set_glyph_advance(RID p_font_rid, int p_size, int32_t p_glyph, const Vector2 &p_advance) {
+void TextServerAdvanced::font_set_glyph_advance(const RID &p_font_rid, int64_t p_size, int64_t p_glyph, const Vector2 &p_advance) {
 	FontDataAdvanced *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND(!fd);
 
@@ -2383,7 +2453,7 @@ void TextServerAdvanced::font_set_glyph_advance(RID p_font_rid, int p_size, int3
 	gl[p_glyph].found = true;
 }
 
-Vector2 TextServerAdvanced::font_get_glyph_offset(RID p_font_rid, const Vector2i &p_size, int32_t p_glyph) const {
+Vector2 TextServerAdvanced::font_get_glyph_offset(const RID &p_font_rid, const Vector2i &p_size, int64_t p_glyph) const {
 	FontDataAdvanced *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND_V(!fd, Vector2());
 
@@ -2398,13 +2468,13 @@ Vector2 TextServerAdvanced::font_get_glyph_offset(RID p_font_rid, const Vector2i
 	const HashMap<int32_t, FontGlyph> &gl = fd->cache[size]->glyph_map;
 
 	if (fd->msdf) {
-		return gl[p_glyph].rect.position * (float)p_size.x / (float)fd->msdf_source_size;
+		return gl[p_glyph].rect.position * (double)p_size.x / (double)fd->msdf_source_size;
 	} else {
 		return gl[p_glyph].rect.position;
 	}
 }
 
-void TextServerAdvanced::font_set_glyph_offset(RID p_font_rid, const Vector2i &p_size, int32_t p_glyph, const Vector2 &p_offset) {
+void TextServerAdvanced::font_set_glyph_offset(const RID &p_font_rid, const Vector2i &p_size, int64_t p_glyph, const Vector2 &p_offset) {
 	FontDataAdvanced *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND(!fd);
 
@@ -2419,7 +2489,7 @@ void TextServerAdvanced::font_set_glyph_offset(RID p_font_rid, const Vector2i &p
 	gl[p_glyph].found = true;
 }
 
-Vector2 TextServerAdvanced::font_get_glyph_size(RID p_font_rid, const Vector2i &p_size, int32_t p_glyph) const {
+Vector2 TextServerAdvanced::font_get_glyph_size(const RID &p_font_rid, const Vector2i &p_size, int64_t p_glyph) const {
 	FontDataAdvanced *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND_V(!fd, Vector2());
 
@@ -2434,13 +2504,13 @@ Vector2 TextServerAdvanced::font_get_glyph_size(RID p_font_rid, const Vector2i &
 	const HashMap<int32_t, FontGlyph> &gl = fd->cache[size]->glyph_map;
 
 	if (fd->msdf) {
-		return gl[p_glyph].rect.size * (float)p_size.x / (float)fd->msdf_source_size;
+		return gl[p_glyph].rect.size * (double)p_size.x / (double)fd->msdf_source_size;
 	} else {
 		return gl[p_glyph].rect.size;
 	}
 }
 
-void TextServerAdvanced::font_set_glyph_size(RID p_font_rid, const Vector2i &p_size, int32_t p_glyph, const Vector2 &p_gl_size) {
+void TextServerAdvanced::font_set_glyph_size(const RID &p_font_rid, const Vector2i &p_size, int64_t p_glyph, const Vector2 &p_gl_size) {
 	FontDataAdvanced *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND(!fd);
 
@@ -2455,7 +2525,7 @@ void TextServerAdvanced::font_set_glyph_size(RID p_font_rid, const Vector2i &p_s
 	gl[p_glyph].found = true;
 }
 
-Rect2 TextServerAdvanced::font_get_glyph_uv_rect(RID p_font_rid, const Vector2i &p_size, int32_t p_glyph) const {
+Rect2 TextServerAdvanced::font_get_glyph_uv_rect(const RID &p_font_rid, const Vector2i &p_size, int64_t p_glyph) const {
 	FontDataAdvanced *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND_V(!fd, Rect2());
 
@@ -2471,7 +2541,7 @@ Rect2 TextServerAdvanced::font_get_glyph_uv_rect(RID p_font_rid, const Vector2i
 	return gl[p_glyph].uv_rect;
 }
 
-void TextServerAdvanced::font_set_glyph_uv_rect(RID p_font_rid, const Vector2i &p_size, int32_t p_glyph, const Rect2 &p_uv_rect) {
+void TextServerAdvanced::font_set_glyph_uv_rect(const RID &p_font_rid, const Vector2i &p_size, int64_t p_glyph, const Rect2 &p_uv_rect) {
 	FontDataAdvanced *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND(!fd);
 
@@ -2486,7 +2556,7 @@ void TextServerAdvanced::font_set_glyph_uv_rect(RID p_font_rid, const Vector2i &
 	gl[p_glyph].found = true;
 }
 
-int TextServerAdvanced::font_get_glyph_texture_idx(RID p_font_rid, const Vector2i &p_size, int32_t p_glyph) const {
+int64_t TextServerAdvanced::font_get_glyph_texture_idx(const RID &p_font_rid, const Vector2i &p_size, int64_t p_glyph) const {
 	FontDataAdvanced *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND_V(!fd, -1);
 
@@ -2502,7 +2572,7 @@ int TextServerAdvanced::font_get_glyph_texture_idx(RID p_font_rid, const Vector2
 	return gl[p_glyph].texture_idx;
 }
 
-void TextServerAdvanced::font_set_glyph_texture_idx(RID p_font_rid, const Vector2i &p_size, int32_t p_glyph, int p_texture_idx) {
+void TextServerAdvanced::font_set_glyph_texture_idx(const RID &p_font_rid, const Vector2i &p_size, int64_t p_glyph, int64_t p_texture_idx) {
 	FontDataAdvanced *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND(!fd);
 
@@ -2517,7 +2587,7 @@ void TextServerAdvanced::font_set_glyph_texture_idx(RID p_font_rid, const Vector
 	gl[p_glyph].found = true;
 }
 
-Dictionary TextServerAdvanced::font_get_glyph_contours(RID p_font_rid, int p_size, int32_t p_index) const {
+Dictionary TextServerAdvanced::font_get_glyph_contours(const RID &p_font_rid, int64_t p_size, int64_t p_index) const {
 	FontDataAdvanced *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND_V(!fd, Dictionary());
 
@@ -2526,20 +2596,19 @@ Dictionary TextServerAdvanced::font_get_glyph_contours(RID p_font_rid, int p_siz
 
 	ERR_FAIL_COND_V(!_ensure_cache_for_size(fd, size), Dictionary());
 
-	Vector<Vector3> points;
-	Vector<int32_t> contours;
+	PackedVector3Array points;
+	PackedInt32Array contours;
 	bool orientation;
 #ifdef MODULE_FREETYPE_ENABLED
-	int error = FT_Load_Glyph(fd->cache[size]->face, p_index, FT_LOAD_NO_BITMAP | (fd->force_autohinter ? FT_LOAD_FORCE_AUTOHINT : 0));
-	ERR_FAIL_COND_V(error, Dictionary());
+	int32_t index = p_index & 0xffffff; // Remove subpixel shifts.
 
-	points.clear();
-	contours.clear();
+	int error = FT_Load_Glyph(fd->cache[size]->face, index, FT_LOAD_NO_BITMAP | (fd->force_autohinter ? FT_LOAD_FORCE_AUTOHINT : 0));
+	ERR_FAIL_COND_V(error, Dictionary());
 
-	float h = fd->cache[size]->ascent;
-	float scale = (1.0 / 64.0) / fd->cache[size]->oversampling * fd->cache[size]->scale;
+	double h = fd->cache[size]->ascent;
+	double scale = (1.0 / 64.0) / fd->cache[size]->oversampling * fd->cache[size]->scale;
 	if (fd->msdf) {
-		scale = scale * (float)p_size / (float)fd->msdf_source_size;
+		scale = scale * (double)p_size / (double)fd->msdf_source_size;
 	}
 	for (short i = 0; i < fd->cache[size]->face->glyph->outline.n_points; i++) {
 		points.push_back(Vector3(fd->cache[size]->face->glyph->outline.points[i].x * scale, h - fd->cache[size]->face->glyph->outline.points[i].y * scale, FT_CURVE_TAG(fd->cache[size]->face->glyph->outline.tags[i])));
@@ -2559,7 +2628,7 @@ Dictionary TextServerAdvanced::font_get_glyph_contours(RID p_font_rid, int p_siz
 	return out;
 }
 
-Array TextServerAdvanced::font_get_kerning_list(RID p_font_rid, int p_size) const {
+Array TextServerAdvanced::font_get_kerning_list(const RID &p_font_rid, int64_t p_size) const {
 	FontDataAdvanced *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND_V(!fd, Array());
 
@@ -2569,13 +2638,13 @@ Array TextServerAdvanced::font_get_kerning_list(RID p_font_rid, int p_size) cons
 	ERR_FAIL_COND_V(!_ensure_cache_for_size(fd, size), Array());
 
 	Array ret;
-	for (const Map<Vector2i, Vector2>::Element *E = fd->cache[size]->kerning_map.front(); E; E = E->next()) {
-		ret.push_back(E->key());
+	for (const KeyValue<Vector2i, FontDataForSizeAdvanced *> &E : fd->cache) {
+		ret.push_back(E.key);
 	}
 	return ret;
 }
 
-void TextServerAdvanced::font_clear_kerning_map(RID p_font_rid, int p_size) {
+void TextServerAdvanced::font_clear_kerning_map(const RID &p_font_rid, int64_t p_size) {
 	FontDataAdvanced *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND(!fd);
 
@@ -2586,7 +2655,7 @@ void TextServerAdvanced::font_clear_kerning_map(RID p_font_rid, int p_size) {
 	fd->cache[size]->kerning_map.clear();
 }
 
-void TextServerAdvanced::font_remove_kerning(RID p_font_rid, int p_size, const Vector2i &p_glyph_pair) {
+void TextServerAdvanced::font_remove_kerning(const RID &p_font_rid, int64_t p_size, const Vector2i &p_glyph_pair) {
 	FontDataAdvanced *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND(!fd);
 
@@ -2597,7 +2666,7 @@ void TextServerAdvanced::font_remove_kerning(RID p_font_rid, int p_size, const V
 	fd->cache[size]->kerning_map.erase(p_glyph_pair);
 }
 
-void TextServerAdvanced::font_set_kerning(RID p_font_rid, int p_size, const Vector2i &p_glyph_pair, const Vector2 &p_kerning) {
+void TextServerAdvanced::font_set_kerning(const RID &p_font_rid, int64_t p_size, const Vector2i &p_glyph_pair, const Vector2 &p_kerning) {
 	FontDataAdvanced *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND(!fd);
 
@@ -2608,7 +2677,7 @@ void TextServerAdvanced::font_set_kerning(RID p_font_rid, int p_size, const Vect
 	fd->cache[size]->kerning_map[p_glyph_pair] = p_kerning;
 }
 
-Vector2 TextServerAdvanced::font_get_kerning(RID p_font_rid, int p_size, const Vector2i &p_glyph_pair) const {
+Vector2 TextServerAdvanced::font_get_kerning(const RID &p_font_rid, int64_t p_size, const Vector2i &p_glyph_pair) const {
 	FontDataAdvanced *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND_V(!fd, Vector2());
 
@@ -2621,7 +2690,7 @@ Vector2 TextServerAdvanced::font_get_kerning(RID p_font_rid, int p_size, const V
 
 	if (kern.has(p_glyph_pair)) {
 		if (fd->msdf) {
-			return kern[p_glyph_pair] * (float)p_size / (float)fd->msdf_source_size;
+			return kern[p_glyph_pair] * (double)p_size / (double)fd->msdf_source_size;
 		} else {
 			return kern[p_glyph_pair];
 		}
@@ -2631,7 +2700,7 @@ Vector2 TextServerAdvanced::font_get_kerning(RID p_font_rid, int p_size, const V
 			FT_Vector delta;
 			FT_Get_Kerning(fd->cache[size]->face, p_glyph_pair.x, p_glyph_pair.y, FT_KERNING_DEFAULT, &delta);
 			if (fd->msdf) {
-				return Vector2(delta.x, delta.y) * (float)p_size / (float)fd->msdf_source_size;
+				return Vector2(delta.x, delta.y) * (double)p_size / (double)fd->msdf_source_size;
 			} else {
 				return Vector2(delta.x, delta.y);
 			}
@@ -2641,7 +2710,7 @@ Vector2 TextServerAdvanced::font_get_kerning(RID p_font_rid, int p_size, const V
 	return Vector2();
 }
 
-int32_t TextServerAdvanced::font_get_glyph_index(RID p_font_rid, int p_size, char32_t p_char, char32_t p_variation_selector) const {
+int64_t TextServerAdvanced::font_get_glyph_index(const RID &p_font_rid, int64_t p_size, int64_t p_char, int64_t p_variation_selector) const {
 	FontDataAdvanced *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND_V(!fd, 0);
 	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) + ".");
@@ -2659,14 +2728,14 @@ int32_t TextServerAdvanced::font_get_glyph_index(RID p_font_rid, int p_size, cha
 			return FT_Get_Char_Index(fd->cache[size]->face, p_char);
 		}
 	} else {
-		return (int32_t)p_char;
+		return (int64_t)p_char;
 	}
 #else
-	return (int32_t)p_char;
+	return (int64_t)p_char;
 #endif
 }
 
-bool TextServerAdvanced::font_has_char(RID p_font_rid, char32_t p_char) const {
+bool TextServerAdvanced::font_has_char(const RID &p_font_rid, int64_t p_char) const {
 	FontDataAdvanced *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND_V(!fd, false);
 	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) + ".");
@@ -2685,7 +2754,7 @@ bool TextServerAdvanced::font_has_char(RID p_font_rid, char32_t p_char) const {
 	return (at_size) ? at_size->glyph_map.has((int32_t)p_char) : false;
 }
 
-String TextServerAdvanced::font_get_supported_chars(RID p_font_rid) const {
+String TextServerAdvanced::font_get_supported_chars(const RID &p_font_rid) const {
 	FontDataAdvanced *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND_V(!fd, String());
 
@@ -2702,7 +2771,7 @@ String TextServerAdvanced::font_get_supported_chars(RID p_font_rid) const {
 		FT_ULong charcode = FT_Get_First_Char(at_size->face, &gindex);
 		while (gindex != 0) {
 			if (charcode != 0) {
-				chars += char32_t(charcode);
+				chars = chars + String::chr(charcode);
 			}
 			charcode = FT_Get_Next_Char(at_size->face, charcode, &gindex);
 		}
@@ -2713,13 +2782,13 @@ String TextServerAdvanced::font_get_supported_chars(RID p_font_rid) const {
 		const HashMap<int32_t, FontGlyph> &gl = at_size->glyph_map;
 		const int32_t *E = nullptr;
 		while ((E = gl.next(E))) {
-			chars += char32_t(*E);
+			chars = chars + String::chr(*E);
 		}
 	}
 	return chars;
 }
 
-void TextServerAdvanced::font_render_range(RID p_font_rid, const Vector2i &p_size, char32_t p_start, char32_t p_end) {
+void TextServerAdvanced::font_render_range(const RID &p_font_rid, const Vector2i &p_size, int64_t p_start, int64_t p_end) {
 	FontDataAdvanced *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) + ".");
@@ -2728,7 +2797,7 @@ void TextServerAdvanced::font_render_range(RID p_font_rid, const Vector2i &p_siz
 	MutexLock lock(fd->mutex);
 	Vector2i size = _get_size_outline(fd, p_size);
 	ERR_FAIL_COND(!_ensure_cache_for_size(fd, size));
-	for (char32_t i = p_start; i <= p_end; i++) {
+	for (int64_t i = p_start; i <= p_end; i++) {
 #ifdef MODULE_FREETYPE_ENABLED
 		int32_t idx = FT_Get_Char_Index(fd->cache[size]->face, i);
 		if (fd->cache[size]->face) {
@@ -2752,7 +2821,7 @@ void TextServerAdvanced::font_render_range(RID p_font_rid, const Vector2i &p_siz
 	}
 }
 
-void TextServerAdvanced::font_render_glyph(RID p_font_rid, const Vector2i &p_size, int32_t p_index) {
+void TextServerAdvanced::font_render_glyph(const RID &p_font_rid, const Vector2i &p_size, int64_t p_index) {
 	FontDataAdvanced *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND(!fd);
 
@@ -2760,7 +2829,7 @@ void TextServerAdvanced::font_render_glyph(RID p_font_rid, const Vector2i &p_siz
 	Vector2i size = _get_size_outline(fd, p_size);
 	ERR_FAIL_COND(!_ensure_cache_for_size(fd, size));
 #ifdef MODULE_FREETYPE_ENABLED
-	int32_t idx = p_index;
+	int32_t idx = p_index & 0xffffff; // Remove subpixel shifts.
 	if (fd->cache[size]->face) {
 		if (fd->msdf) {
 			_ensure_glyph(fd, size, (int32_t)idx);
@@ -2781,7 +2850,7 @@ void TextServerAdvanced::font_render_glyph(RID p_font_rid, const Vector2i &p_siz
 #endif
 }
 
-void TextServerAdvanced::font_draw_glyph(RID p_font_rid, RID p_canvas, int p_size, const Vector2 &p_pos, int32_t p_index, const Color &p_color) const {
+void TextServerAdvanced::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 {
 	FontDataAdvanced *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND(!fd);
 
@@ -2789,7 +2858,7 @@ void TextServerAdvanced::font_draw_glyph(RID p_font_rid, RID p_canvas, int p_siz
 	Vector2i size = _get_size(fd, p_size);
 	ERR_FAIL_COND(!_ensure_cache_for_size(fd, size));
 
-	int32_t index = p_index;
+	int32_t index = p_index & 0xffffff; // Remove subpixel shifts.
 
 #ifdef MODULE_FREETYPE_ENABLED
 	if (!fd->msdf && fd->cache[size]->face) {
@@ -2822,8 +2891,8 @@ void TextServerAdvanced::font_draw_glyph(RID p_font_rid, RID p_canvas, int p_siz
 				RID texture = fd->cache[size]->textures[gl.texture_idx].texture->get_rid();
 				if (fd->msdf) {
 					Point2 cpos = p_pos;
-					cpos += gl.rect.position * (float)p_size / (float)fd->msdf_source_size;
-					Size2 csize = gl.rect.size * (float)p_size / (float)fd->msdf_source_size;
+					cpos += gl.rect.position * (double)p_size / (double)fd->msdf_source_size;
+					Size2 csize = gl.rect.size * (double)p_size / (double)fd->msdf_source_size;
 					RenderingServer::get_singleton()->canvas_item_add_msdf_texture_rect_region(p_canvas, Rect2(cpos, csize), texture, gl.uv_rect, modulate, 0, fd->msdf_range);
 				} else {
 					Point2 cpos = p_pos;
@@ -2844,7 +2913,7 @@ void TextServerAdvanced::font_draw_glyph(RID p_font_rid, RID p_canvas, int p_siz
 	}
 }
 
-void TextServerAdvanced::font_draw_glyph_outline(RID p_font_rid, RID p_canvas, int p_size, int p_outline_size, const Vector2 &p_pos, int32_t p_index, const Color &p_color) const {
+void TextServerAdvanced::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 {
 	FontDataAdvanced *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND(!fd);
 
@@ -2852,7 +2921,7 @@ void TextServerAdvanced::font_draw_glyph_outline(RID p_font_rid, RID p_canvas, i
 	Vector2i size = _get_size_outline(fd, Vector2i(p_size, p_outline_size));
 	ERR_FAIL_COND(!_ensure_cache_for_size(fd, size));
 
-	int32_t index = p_index;
+	int32_t index = p_index & 0xffffff; // Remove subpixel shifts.
 
 #ifdef MODULE_FREETYPE_ENABLED
 	if (!fd->msdf && fd->cache[size]->face) {
@@ -2885,8 +2954,8 @@ void TextServerAdvanced::font_draw_glyph_outline(RID p_font_rid, RID p_canvas, i
 				RID texture = fd->cache[size]->textures[gl.texture_idx].texture->get_rid();
 				if (fd->msdf) {
 					Point2 cpos = p_pos;
-					cpos += gl.rect.position * (float)p_size / (float)fd->msdf_source_size;
-					Size2 csize = gl.rect.size * (float)p_size / (float)fd->msdf_source_size;
+					cpos += gl.rect.position * (double)p_size / (double)fd->msdf_source_size;
+					Size2 csize = gl.rect.size * (double)p_size / (double)fd->msdf_source_size;
 					RenderingServer::get_singleton()->canvas_item_add_msdf_texture_rect_region(p_canvas, Rect2(cpos, csize), texture, gl.uv_rect, modulate, p_outline_size * 2, fd->msdf_range);
 				} else {
 					Point2 cpos = p_pos;
@@ -2907,7 +2976,7 @@ void TextServerAdvanced::font_draw_glyph_outline(RID p_font_rid, RID p_canvas, i
 	}
 }
 
-bool TextServerAdvanced::font_is_language_supported(RID p_font_rid, const String &p_language) const {
+bool TextServerAdvanced::font_is_language_supported(const RID &p_font_rid, const String &p_language) const {
 	FontDataAdvanced *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND_V(!fd, false);
 
@@ -2919,7 +2988,7 @@ bool TextServerAdvanced::font_is_language_supported(RID p_font_rid, const String
 	}
 }
 
-void TextServerAdvanced::font_set_language_support_override(RID p_font_rid, const String &p_language, bool p_supported) {
+void TextServerAdvanced::font_set_language_support_override(const RID &p_font_rid, const String &p_language, bool p_supported) {
 	FontDataAdvanced *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND(!fd);
 
@@ -2927,7 +2996,7 @@ void TextServerAdvanced::font_set_language_support_override(RID p_font_rid, cons
 	fd->language_support_overrides[p_language] = p_supported;
 }
 
-bool TextServerAdvanced::font_get_language_support_override(RID p_font_rid, const String &p_language) {
+bool TextServerAdvanced::font_get_language_support_override(const RID &p_font_rid, const String &p_language) {
 	FontDataAdvanced *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND_V(!fd, false);
 
@@ -2935,7 +3004,7 @@ bool TextServerAdvanced::font_get_language_support_override(RID p_font_rid, cons
 	return fd->language_support_overrides[p_language];
 }
 
-void TextServerAdvanced::font_remove_language_support_override(RID p_font_rid, const String &p_language) {
+void TextServerAdvanced::font_remove_language_support_override(const RID &p_font_rid, const String &p_language) {
 	FontDataAdvanced *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND(!fd);
 
@@ -2943,19 +3012,19 @@ void TextServerAdvanced::font_remove_language_support_override(RID p_font_rid, c
 	fd->language_support_overrides.erase(p_language);
 }
 
-Vector<String> TextServerAdvanced::font_get_language_support_overrides(RID p_font_rid) {
+PackedStringArray TextServerAdvanced::font_get_language_support_overrides(const RID &p_font_rid) {
 	FontDataAdvanced *fd = font_owner.get_or_null(p_font_rid);
-	ERR_FAIL_COND_V(!fd, Vector<String>());
+	ERR_FAIL_COND_V(!fd, PackedStringArray());
 
 	MutexLock lock(fd->mutex);
-	Vector<String> out;
+	PackedStringArray out;
 	for (const KeyValue<String, bool> &E : fd->language_support_overrides) {
 		out.push_back(E.key);
 	}
 	return out;
 }
 
-bool TextServerAdvanced::font_is_script_supported(RID p_font_rid, const String &p_script) const {
+bool TextServerAdvanced::font_is_script_supported(const RID &p_font_rid, const String &p_script) const {
 	FontDataAdvanced *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND_V(!fd, false);
 
@@ -2969,7 +3038,7 @@ bool TextServerAdvanced::font_is_script_supported(RID p_font_rid, const String &
 	}
 }
 
-void TextServerAdvanced::font_set_script_support_override(RID p_font_rid, const String &p_script, bool p_supported) {
+void TextServerAdvanced::font_set_script_support_override(const RID &p_font_rid, const String &p_script, bool p_supported) {
 	FontDataAdvanced *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND(!fd);
 
@@ -2977,7 +3046,7 @@ void TextServerAdvanced::font_set_script_support_override(RID p_font_rid, const
 	fd->script_support_overrides[p_script] = p_supported;
 }
 
-bool TextServerAdvanced::font_get_script_support_override(RID p_font_rid, const String &p_script) {
+bool TextServerAdvanced::font_get_script_support_override(const RID &p_font_rid, const String &p_script) {
 	FontDataAdvanced *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND_V(!fd, false);
 
@@ -2985,7 +3054,7 @@ bool TextServerAdvanced::font_get_script_support_override(RID p_font_rid, const
 	return fd->script_support_overrides[p_script];
 }
 
-void TextServerAdvanced::font_remove_script_support_override(RID p_font_rid, const String &p_script) {
+void TextServerAdvanced::font_remove_script_support_override(const RID &p_font_rid, const String &p_script) {
 	FontDataAdvanced *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND(!fd);
 
@@ -2993,19 +3062,19 @@ void TextServerAdvanced::font_remove_script_support_override(RID p_font_rid, con
 	fd->script_support_overrides.erase(p_script);
 }
 
-Vector<String> TextServerAdvanced::font_get_script_support_overrides(RID p_font_rid) {
+PackedStringArray TextServerAdvanced::font_get_script_support_overrides(const RID &p_font_rid) {
 	FontDataAdvanced *fd = font_owner.get_or_null(p_font_rid);
-	ERR_FAIL_COND_V(!fd, Vector<String>());
+	ERR_FAIL_COND_V(!fd, PackedStringArray());
 
 	MutexLock lock(fd->mutex);
-	Vector<String> out;
-	for (const Map<String, bool>::Element *E = fd->script_support_overrides.front(); E; E = E->next()) {
-		out.push_back(E->key());
+	PackedStringArray out;
+	for (const KeyValue<String, bool> &E : fd->script_support_overrides) {
+		out.push_back(E.key);
 	}
 	return out;
 }
 
-void TextServerAdvanced::font_set_opentype_feature_overrides(RID p_font_rid, const Dictionary &p_overrides) {
+void TextServerAdvanced::font_set_opentype_feature_overrides(const RID &p_font_rid, const Dictionary &p_overrides) {
 	FontDataAdvanced *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND(!fd);
 
@@ -3015,7 +3084,7 @@ void TextServerAdvanced::font_set_opentype_feature_overrides(RID p_font_rid, con
 	fd->feature_overrides = p_overrides;
 }
 
-Dictionary TextServerAdvanced::font_get_opentype_feature_overrides(RID p_font_rid) const {
+Dictionary TextServerAdvanced::font_get_opentype_feature_overrides(const RID &p_font_rid) const {
 	FontDataAdvanced *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND_V(!fd, Dictionary());
 
@@ -3023,7 +3092,7 @@ Dictionary TextServerAdvanced::font_get_opentype_feature_overrides(RID p_font_ri
 	return fd->feature_overrides;
 }
 
-Dictionary TextServerAdvanced::font_supported_feature_list(RID p_font_rid) const {
+Dictionary TextServerAdvanced::font_supported_feature_list(const RID &p_font_rid) const {
 	FontDataAdvanced *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND_V(!fd, Dictionary());
 
@@ -3033,7 +3102,7 @@ Dictionary TextServerAdvanced::font_supported_feature_list(RID p_font_rid) const
 	return fd->supported_features;
 }
 
-Dictionary TextServerAdvanced::font_supported_variation_list(RID p_font_rid) const {
+Dictionary TextServerAdvanced::font_supported_variation_list(const RID &p_font_rid) const {
 	FontDataAdvanced *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND_V(!fd, Dictionary());
 
@@ -3043,11 +3112,11 @@ Dictionary TextServerAdvanced::font_supported_variation_list(RID p_font_rid) con
 	return fd->supported_varaitions;
 }
 
-float TextServerAdvanced::font_get_global_oversampling() const {
+double TextServerAdvanced::font_get_global_oversampling() const {
 	return oversampling;
 }
 
-void TextServerAdvanced::font_set_global_oversampling(float p_oversampling) {
+void TextServerAdvanced::font_set_global_oversampling(double p_oversampling) {
 	_THREAD_SAFE_METHOD_
 	if (oversampling != p_oversampling) {
 		oversampling = p_oversampling;
@@ -3075,10 +3144,10 @@ void TextServerAdvanced::font_set_global_oversampling(float p_oversampling) {
 /* Shaped text buffer interface                                          */
 /*************************************************************************/
 
-int TextServerAdvanced::_convert_pos(const ShapedTextDataAdvanced *p_sd, int p_pos) const {
-	int32_t limit = p_pos;
+int64_t TextServerAdvanced::_convert_pos(const ShapedTextDataAdvanced *p_sd, int64_t p_pos) const {
+	int64_t limit = p_pos;
 	if (p_sd->text.length() != p_sd->utf16.length()) {
-		const UChar *data = p_sd->utf16.ptr();
+		const UChar *data = p_sd->utf16.get_data();
 		for (int i = 0; i < p_pos; i++) {
 			if (U16_IS_LEAD(data[i])) {
 				limit--;
@@ -3088,11 +3157,11 @@ int TextServerAdvanced::_convert_pos(const ShapedTextDataAdvanced *p_sd, int p_p
 	return limit;
 }
 
-int TextServerAdvanced::_convert_pos_inv(const ShapedTextDataAdvanced *p_sd, int p_pos) const {
-	int32_t limit = p_pos;
+int64_t TextServerAdvanced::_convert_pos_inv(const ShapedTextDataAdvanced *p_sd, int64_t p_pos) const {
+	int64_t limit = p_pos;
 	if (p_sd->text.length() != p_sd->utf16.length()) {
 		for (int i = 0; i < p_pos; i++) {
-			if (p_sd->text[i] > 0xFFFF) {
+			if (p_sd->text[i] > 0xffff) {
 				limit++;
 			}
 		}
@@ -3106,11 +3175,11 @@ void TextServerAdvanced::invalidate(TextServerAdvanced::ShapedTextDataAdvanced *
 	p_shaped->line_breaks_valid = false;
 	p_shaped->justification_ops_valid = false;
 	p_shaped->text_trimmed = false;
-	p_shaped->ascent = 0.f;
-	p_shaped->descent = 0.f;
-	p_shaped->width = 0.f;
-	p_shaped->upos = 0.f;
-	p_shaped->uthk = 0.f;
+	p_shaped->ascent = 0.0;
+	p_shaped->descent = 0.0;
+	p_shaped->width = 0.0;
+	p_shaped->upos = 0.0;
+	p_shaped->uthk = 0.0;
 	p_shaped->glyphs.clear();
 	p_shaped->glyphs_logical.clear();
 	p_shaped->overrun_trim_data = TrimData();
@@ -3161,7 +3230,7 @@ RID TextServerAdvanced::create_shaped_text(TextServer::Direction p_direction, Te
 	return shaped_owner.make_rid(sd);
 }
 
-void TextServerAdvanced::shaped_text_clear(RID p_shaped) {
+void TextServerAdvanced::shaped_text_clear(const RID &p_shaped) {
 	ShapedTextDataAdvanced *sd = shaped_owner.get_or_null(p_shaped);
 	ERR_FAIL_COND(!sd);
 
@@ -3176,7 +3245,7 @@ void TextServerAdvanced::shaped_text_clear(RID p_shaped) {
 	invalidate(sd, true);
 }
 
-void TextServerAdvanced::shaped_text_set_direction(RID p_shaped, TextServer::Direction p_direction) {
+void TextServerAdvanced::shaped_text_set_direction(const RID &p_shaped, TextServer::Direction p_direction) {
 	ShapedTextDataAdvanced *sd = shaped_owner.get_or_null(p_shaped);
 	ERR_FAIL_COND(!sd);
 
@@ -3190,7 +3259,7 @@ void TextServerAdvanced::shaped_text_set_direction(RID p_shaped, TextServer::Dir
 	}
 }
 
-TextServer::Direction TextServerAdvanced::shaped_text_get_direction(RID p_shaped) const {
+TextServer::Direction TextServerAdvanced::shaped_text_get_direction(const RID &p_shaped) const {
 	const ShapedTextDataAdvanced *sd = shaped_owner.get_or_null(p_shaped);
 	ERR_FAIL_COND_V(!sd, TextServer::DIRECTION_LTR);
 
@@ -3198,7 +3267,7 @@ TextServer::Direction TextServerAdvanced::shaped_text_get_direction(RID p_shaped
 	return sd->direction;
 }
 
-TextServer::Direction TextServerAdvanced::shaped_text_get_inferred_direction(RID p_shaped) const {
+TextServer::Direction TextServerAdvanced::shaped_text_get_inferred_direction(const RID &p_shaped) const {
 	const ShapedTextDataAdvanced *sd = shaped_owner.get_or_null(p_shaped);
 	ERR_FAIL_COND_V(!sd, TextServer::DIRECTION_LTR);
 
@@ -3206,7 +3275,7 @@ TextServer::Direction TextServerAdvanced::shaped_text_get_inferred_direction(RID
 	return sd->para_direction;
 }
 
-void TextServerAdvanced::shaped_text_set_custom_punctuation(RID p_shaped, const String &p_punct) {
+void TextServerAdvanced::shaped_text_set_custom_punctuation(const RID &p_shaped, const String &p_punct) {
 	_THREAD_SAFE_METHOD_
 	ShapedTextDataAdvanced *sd = shaped_owner.get_or_null(p_shaped);
 	ERR_FAIL_COND(!sd);
@@ -3220,14 +3289,14 @@ void TextServerAdvanced::shaped_text_set_custom_punctuation(RID p_shaped, const
 	}
 }
 
-String TextServerAdvanced::shaped_text_get_custom_punctuation(RID p_shaped) const {
+String TextServerAdvanced::shaped_text_get_custom_punctuation(const RID &p_shaped) const {
 	_THREAD_SAFE_METHOD_
 	const ShapedTextDataAdvanced *sd = shaped_owner.get_or_null(p_shaped);
 	ERR_FAIL_COND_V(!sd, String());
 	return sd->custom_punct;
 }
 
-void TextServerAdvanced::shaped_text_set_bidi_override(RID p_shaped, const Array &p_override) {
+void TextServerAdvanced::shaped_text_set_bidi_override(const RID &p_shaped, const Array &p_override) {
 	ShapedTextDataAdvanced *sd = shaped_owner.get_or_null(p_shaped);
 	ERR_FAIL_COND(!sd);
 
@@ -3242,7 +3311,7 @@ void TextServerAdvanced::shaped_text_set_bidi_override(RID p_shaped, const Array
 	invalidate(sd, false);
 }
 
-void TextServerAdvanced::shaped_text_set_orientation(RID p_shaped, TextServer::Orientation p_orientation) {
+void TextServerAdvanced::shaped_text_set_orientation(const RID &p_shaped, TextServer::Orientation p_orientation) {
 	ShapedTextDataAdvanced *sd = shaped_owner.get_or_null(p_shaped);
 	ERR_FAIL_COND(!sd);
 
@@ -3256,7 +3325,7 @@ void TextServerAdvanced::shaped_text_set_orientation(RID p_shaped, TextServer::O
 	}
 }
 
-void TextServerAdvanced::shaped_text_set_preserve_invalid(RID p_shaped, bool p_enabled) {
+void TextServerAdvanced::shaped_text_set_preserve_invalid(const RID &p_shaped, bool p_enabled) {
 	ShapedTextDataAdvanced *sd = shaped_owner.get_or_null(p_shaped);
 	ERR_FAIL_COND(!sd);
 
@@ -3268,7 +3337,7 @@ void TextServerAdvanced::shaped_text_set_preserve_invalid(RID p_shaped, bool p_e
 	}
 }
 
-bool TextServerAdvanced::shaped_text_get_preserve_invalid(RID p_shaped) const {
+bool TextServerAdvanced::shaped_text_get_preserve_invalid(const RID &p_shaped) const {
 	const ShapedTextDataAdvanced *sd = shaped_owner.get_or_null(p_shaped);
 	ERR_FAIL_COND_V(!sd, false);
 
@@ -3276,7 +3345,7 @@ bool TextServerAdvanced::shaped_text_get_preserve_invalid(RID p_shaped) const {
 	return sd->preserve_invalid;
 }
 
-void TextServerAdvanced::shaped_text_set_preserve_control(RID p_shaped, bool p_enabled) {
+void TextServerAdvanced::shaped_text_set_preserve_control(const RID &p_shaped, bool p_enabled) {
 	ShapedTextDataAdvanced *sd = shaped_owner.get_or_null(p_shaped);
 	ERR_FAIL_COND(!sd);
 
@@ -3290,7 +3359,7 @@ void TextServerAdvanced::shaped_text_set_preserve_control(RID p_shaped, bool p_e
 	}
 }
 
-bool TextServerAdvanced::shaped_text_get_preserve_control(RID p_shaped) const {
+bool TextServerAdvanced::shaped_text_get_preserve_control(const RID &p_shaped) const {
 	const ShapedTextDataAdvanced *sd = shaped_owner.get_or_null(p_shaped);
 	ERR_FAIL_COND_V(!sd, false);
 
@@ -3298,7 +3367,7 @@ bool TextServerAdvanced::shaped_text_get_preserve_control(RID p_shaped) const {
 	return sd->preserve_control;
 }
 
-TextServer::Orientation TextServerAdvanced::shaped_text_get_orientation(RID p_shaped) const {
+TextServer::Orientation TextServerAdvanced::shaped_text_get_orientation(const RID &p_shaped) const {
 	const ShapedTextDataAdvanced *sd = shaped_owner.get_or_null(p_shaped);
 	ERR_FAIL_COND_V(!sd, TextServer::ORIENTATION_HORIZONTAL);
 
@@ -3306,25 +3375,25 @@ TextServer::Orientation TextServerAdvanced::shaped_text_get_orientation(RID p_sh
 	return sd->orientation;
 }
 
-int TextServerAdvanced::shaped_get_span_count(RID p_shaped) const {
+int64_t TextServerAdvanced::shaped_get_span_count(const RID &p_shaped) const {
 	ShapedTextDataAdvanced *sd = shaped_owner.get_or_null(p_shaped);
 	ERR_FAIL_COND_V(!sd, 0);
 	return sd->spans.size();
 }
 
-Variant TextServerAdvanced::shaped_get_span_meta(RID p_shaped, int p_index) const {
+Variant TextServerAdvanced::shaped_get_span_meta(const RID &p_shaped, int64_t p_index) const {
 	ShapedTextDataAdvanced *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 TextServerAdvanced::shaped_set_span_update_font(RID p_shaped, int p_index, const Vector<RID> &p_fonts, int p_size, const Dictionary &p_opentype_features) {
+void TextServerAdvanced::shaped_set_span_update_font(const RID &p_shaped, int64_t p_index, const Array &p_fonts, int64_t p_size, const Dictionary &p_opentype_features) {
 	ShapedTextDataAdvanced *sd = shaped_owner.get_or_null(p_shaped);
 	ERR_FAIL_COND(!sd);
 	ERR_FAIL_INDEX(p_index, sd->spans.size());
 
-	ShapedTextDataAdvanced::Span &span = sd->spans.write[p_index];
+	ShapedTextDataAdvanced::Span &span = sd->spans.ptrw()[p_index];
 	bool changed = (span.font_size != p_size) || (span.features != p_opentype_features) || (p_fonts.size() != span.fonts.size());
 	if (!changed) {
 		for (int i = 0; i < p_fonts.size(); i++) {
@@ -3340,7 +3409,7 @@ void TextServerAdvanced::shaped_set_span_update_font(RID p_shaped, int p_index,
 	}
 }
 
-bool TextServerAdvanced::shaped_text_add_string(RID p_shaped, const String &p_text, const Vector<RID> &p_fonts, int p_size, const Dictionary &p_opentype_features, const String &p_language, const Variant &p_meta) {
+bool TextServerAdvanced::shaped_text_add_string(const RID &p_shaped, const String &p_text, const Array &p_fonts, int64_t p_size, const Dictionary &p_opentype_features, const String &p_language, const Variant &p_meta) {
 	ShapedTextDataAdvanced *sd = shaped_owner.get_or_null(p_shaped);
 	ERR_FAIL_COND_V(!sd, false);
 	ERR_FAIL_COND_V(p_size <= 0, false);
@@ -3368,14 +3437,14 @@ bool TextServerAdvanced::shaped_text_add_string(RID p_shaped, const String &p_te
 	span.meta = p_meta;
 
 	sd->spans.push_back(span);
-	sd->text += p_text;
+	sd->text = sd->text + p_text;
 	sd->end += p_text.length();
 	invalidate(sd, true);
 
 	return true;
 }
 
-bool TextServerAdvanced::shaped_text_add_object(RID p_shaped, Variant p_key, const Size2 &p_size, InlineAlignment p_inline_align, int p_length) {
+bool TextServerAdvanced::shaped_text_add_object(const RID &p_shaped, const Variant &p_key, const Size2 &p_size, InlineAlignment p_inline_align, int64_t p_length) {
 	_THREAD_SAFE_METHOD_
 	ShapedTextDataAdvanced *sd = shaped_owner.get_or_null(p_shaped);
 	ERR_FAIL_COND_V(!sd, false);
@@ -3397,7 +3466,7 @@ bool TextServerAdvanced::shaped_text_add_object(RID p_shaped, Variant p_key, con
 	obj.pos = span.start;
 
 	sd->spans.push_back(span);
-	sd->text += String::chr(0xfffc).repeat(p_length);
+	sd->text = sd->text + String::chr(0xfffc).repeat(p_length);
 	sd->end += p_length;
 	sd->objects[p_key] = obj;
 	invalidate(sd, true);
@@ -3405,7 +3474,7 @@ bool TextServerAdvanced::shaped_text_add_object(RID p_shaped, Variant p_key, con
 	return true;
 }
 
-bool TextServerAdvanced::shaped_text_resize_object(RID p_shaped, Variant p_key, const Size2 &p_size, InlineAlignment p_inline_align) {
+bool TextServerAdvanced::shaped_text_resize_object(const RID &p_shaped, const Variant &p_key, const Size2 &p_size, InlineAlignment p_inline_align) {
 	ShapedTextDataAdvanced *sd = shaped_owner.get_or_null(p_shaped);
 	ERR_FAIL_COND_V(!sd, false);
 
@@ -3459,8 +3528,8 @@ bool TextServerAdvanced::shaped_text_resize_object(RID p_shaped, Variant p_key,
 					if (sd->orientation == ORIENTATION_HORIZONTAL) {
 						sd->ascent = MAX(sd->ascent, get_hex_code_box_size(gl.font_size, gl.index).y);
 					} else {
-						sd->ascent = MAX(sd->ascent, Math::round(get_hex_code_box_size(gl.font_size, gl.index).x * 0.5f));
-						sd->descent = MAX(sd->descent, Math::round(get_hex_code_box_size(gl.font_size, gl.index).x * 0.5f));
+						sd->ascent = MAX(sd->ascent, Math::round(get_hex_code_box_size(gl.font_size, gl.index).x * 0.5));
+						sd->descent = MAX(sd->descent, Math::round(get_hex_code_box_size(gl.font_size, gl.index).x * 0.5));
 					}
 				}
 				sd->width += gl.advance * gl.repeat;
@@ -3473,8 +3542,8 @@ bool TextServerAdvanced::shaped_text_resize_object(RID p_shaped, Variant p_key,
 
 void TextServerAdvanced::_realign(ShapedTextDataAdvanced *p_sd) const {
 	// Align embedded objects to baseline.
-	float full_ascent = p_sd->ascent;
-	float full_descent = p_sd->descent;
+	double full_ascent = p_sd->ascent;
+	double full_descent = p_sd->descent;
 	for (KeyValue<Variant, ShapedTextDataAdvanced::EmbeddedObject> &E : p_sd->objects) {
 		if ((E.value.pos >= p_sd->start) && (E.value.pos < p_sd->end)) {
 			if (p_sd->orientation == ORIENTATION_HORIZONTAL) {
@@ -3540,7 +3609,7 @@ void TextServerAdvanced::_realign(ShapedTextDataAdvanced *p_sd) const {
 	p_sd->descent = full_descent;
 }
 
-RID TextServerAdvanced::shaped_text_substr(RID p_shaped, int p_start, int p_length) const {
+RID TextServerAdvanced::shaped_text_substr(const RID &p_shaped, int64_t p_start, int64_t p_length) const {
 	const ShapedTextDataAdvanced *sd = shaped_owner.get_or_null(p_shaped);
 	ERR_FAIL_COND_V(!sd, RID());
 
@@ -3571,7 +3640,7 @@ RID TextServerAdvanced::shaped_text_substr(RID p_shaped, int p_start, int p_leng
 	return shaped_owner.make_rid(new_sd);
 }
 
-bool TextServerAdvanced::_shape_substr(ShapedTextDataAdvanced *p_new_sd, const ShapedTextDataAdvanced *p_sd, int p_start, int p_length) const {
+bool TextServerAdvanced::_shape_substr(ShapedTextDataAdvanced *p_new_sd, const ShapedTextDataAdvanced *p_sd, int64_t p_start, int64_t p_length) const {
 	if (p_new_sd->valid) {
 		return true;
 	}
@@ -3661,8 +3730,8 @@ bool TextServerAdvanced::_shape_substr(ShapedTextDataAdvanced *p_new_sd, const S
 								if (p_new_sd->orientation == ORIENTATION_HORIZONTAL) {
 									p_new_sd->ascent = MAX(p_new_sd->ascent, get_hex_code_box_size(gl.font_size, gl.index).y);
 								} else {
-									p_new_sd->ascent = MAX(p_new_sd->ascent, Math::round(get_hex_code_box_size(gl.font_size, gl.index).x * 0.5f));
-									p_new_sd->descent = MAX(p_new_sd->descent, Math::round(get_hex_code_box_size(gl.font_size, gl.index).x * 0.5f));
+									p_new_sd->ascent = MAX(p_new_sd->ascent, Math::round(get_hex_code_box_size(gl.font_size, gl.index).x * 0.5));
+									p_new_sd->descent = MAX(p_new_sd->descent, Math::round(get_hex_code_box_size(gl.font_size, gl.index).x * 0.5));
 								}
 							}
 							p_new_sd->width += gl.advance * gl.repeat;
@@ -3680,7 +3749,7 @@ bool TextServerAdvanced::_shape_substr(ShapedTextDataAdvanced *p_new_sd, const S
 	return true;
 }
 
-RID TextServerAdvanced::shaped_text_get_parent(RID p_shaped) const {
+RID TextServerAdvanced::shaped_text_get_parent(const RID &p_shaped) const {
 	ShapedTextDataAdvanced *sd = shaped_owner.get_or_null(p_shaped);
 	ERR_FAIL_COND_V(!sd, RID());
 
@@ -3688,9 +3757,9 @@ RID TextServerAdvanced::shaped_text_get_parent(RID p_shaped) const {
 	return sd->parent;
 }
 
-float TextServerAdvanced::shaped_text_fit_to_width(RID p_shaped, float p_width, uint16_t /*JustificationFlag*/ p_jst_flags) {
+double TextServerAdvanced::shaped_text_fit_to_width(const RID &p_shaped, double p_width, int64_t /*JustificationFlag*/ p_jst_flags) {
 	ShapedTextDataAdvanced *sd = shaped_owner.get_or_null(p_shaped);
-	ERR_FAIL_COND_V(!sd, 0.f);
+	ERR_FAIL_COND_V(!sd, 0.0);
 
 	MutexLock lock(sd->mutex);
 	if (!sd->valid) {
@@ -3729,7 +3798,7 @@ float TextServerAdvanced::shaped_text_fit_to_width(RID p_shaped, float p_width,
 		}
 	}
 
-	float justification_width;
+	double justification_width;
 	if ((p_jst_flags & JUSTIFICATION_CONSTRAIN_ELLIPSIS) == JUSTIFICATION_CONSTRAIN_ELLIPSIS) {
 		if (sd->overrun_trim_data.trim_pos >= 0) {
 			if (sd->para_direction == DIRECTION_RTL) {
@@ -3785,7 +3854,7 @@ float TextServerAdvanced::shaped_text_fit_to_width(RID p_shaped, float p_width,
 	}
 
 	if ((elongation_count > 0) && ((p_jst_flags & JUSTIFICATION_KASHIDA) == JUSTIFICATION_KASHIDA)) {
-		float delta_width_per_kashida = (p_width - justification_width) / elongation_count;
+		double delta_width_per_kashida = (p_width - justification_width) / elongation_count;
 		for (int i = start_pos; i <= end_pos; i++) {
 			Glyph &gl = sd->glyphs.write[i];
 			if (gl.count > 0) {
@@ -3805,17 +3874,17 @@ float TextServerAdvanced::shaped_text_fit_to_width(RID p_shaped, float p_width,
 			}
 		}
 	}
-	float adv_remain = 0;
+	double adv_remain = 0;
 	if ((space_count > 0) && ((p_jst_flags & JUSTIFICATION_WORD_BOUND) == JUSTIFICATION_WORD_BOUND)) {
-		float delta_width_per_space = (p_width - justification_width) / space_count;
+		double delta_width_per_space = (p_width - justification_width) / space_count;
 		for (int i = start_pos; i <= end_pos; i++) {
 			Glyph &gl = sd->glyphs.write[i];
 			if (gl.count > 0) {
 				if ((gl.flags & GRAPHEME_IS_SPACE) == GRAPHEME_IS_SPACE) {
-					float old_adv = gl.advance;
-					float new_advance;
+					double old_adv = gl.advance;
+					double new_advance;
 					if ((gl.flags & GRAPHEME_IS_VIRTUAL) == GRAPHEME_IS_VIRTUAL) {
-						new_advance = MAX(gl.advance + delta_width_per_space, 0.f);
+						new_advance = MAX(gl.advance + delta_width_per_space, 0.0);
 					} else {
 						new_advance = MAX(gl.advance + delta_width_per_space, 0.1 * gl.font_size);
 					}
@@ -3845,9 +3914,9 @@ float TextServerAdvanced::shaped_text_fit_to_width(RID p_shaped, float p_width,
 	return Math::ceil(justification_width);
 }
 
-float TextServerAdvanced::shaped_text_tab_align(RID p_shaped, const PackedFloat32Array &p_tab_stops) {
+double TextServerAdvanced::shaped_text_tab_align(const RID &p_shaped, const PackedFloat32Array &p_tab_stops) {
 	ShapedTextDataAdvanced *sd = shaped_owner.get_or_null(p_shaped);
-	ERR_FAIL_COND_V(!sd, 0.f);
+	ERR_FAIL_COND_V(!sd, 0.0);
 
 	MutexLock lock(sd->mutex);
 	if (!sd->valid) {
@@ -3859,12 +3928,12 @@ float TextServerAdvanced::shaped_text_tab_align(RID p_shaped, const PackedFloat3
 
 	for (int i = 0; i < p_tab_stops.size(); i++) {
 		if (p_tab_stops[i] <= 0) {
-			return 0.f;
+			return 0.0;
 		}
 	}
 
 	int tab_index = 0;
-	float off = 0.f;
+	double off = 0.0;
 
 	int start, end, delta;
 	if (sd->para_direction == DIRECTION_LTR) {
@@ -3881,7 +3950,7 @@ float TextServerAdvanced::shaped_text_tab_align(RID p_shaped, const PackedFloat3
 
 	for (int i = start; i != end; i += delta) {
 		if ((gl[i].flags & GRAPHEME_IS_TAB) == GRAPHEME_IS_TAB) {
-			float tab_off = 0.f;
+			double tab_off = 0.0;
 			while (tab_off <= off) {
 				tab_off += p_tab_stops[tab_index];
 				tab_index++;
@@ -3889,7 +3958,7 @@ float TextServerAdvanced::shaped_text_tab_align(RID p_shaped, const PackedFloat3
 					tab_index = 0;
 				}
 			}
-			float old_adv = gl[i].advance;
+			double old_adv = gl[i].advance;
 			gl[i].advance = tab_off - off;
 			sd->width += gl[i].advance - old_adv;
 			off = 0;
@@ -3898,10 +3967,10 @@ float TextServerAdvanced::shaped_text_tab_align(RID p_shaped, const PackedFloat3
 		off += gl[i].advance * gl[i].repeat;
 	}
 
-	return 0.f;
+	return 0.0;
 }
 
-void TextServerAdvanced::shaped_text_overrun_trim_to_width(RID p_shaped_line, float p_width, uint16_t p_trim_flags) {
+void TextServerAdvanced::shaped_text_overrun_trim_to_width(const RID &p_shaped_line, double p_width, int64_t p_trim_flags) {
 	ShapedTextDataAdvanced *sd = shaped_owner.get_or_null(p_shaped_line);
 	ERR_FAIL_COND_MSG(!sd, "ShapedTextDataAdvanced invalid.");
 
@@ -3947,20 +4016,20 @@ void TextServerAdvanced::shaped_text_overrun_trim_to_width(RID p_shaped_line, fl
 	// 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, '.')) {
-		const Vector<RID> &fonts = spans[spans.size() - 1].fonts;
-		for (const RID &font : fonts) {
-			if (font_has_char(font, '.')) {
-				dot_gl_font_rid = font;
+		const Array &fonts = spans[spans.size() - 1].fonts;
+		for (int i = 0; i < fonts.size(); 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, '.')) {
-		const Vector<RID> &fonts = spans[spans.size() - 1].fonts;
-		for (const RID &font : fonts) {
-			if (font_has_char(font, ' ')) {
-				whitespace_gl_font_rid = font;
+		const Array &fonts = spans[spans.size() - 1].fonts;
+		for (int i = 0; i < fonts.size(); i++) {
+			if (font_has_char(fonts[i], ' ')) {
+				whitespace_gl_font_rid = fonts[i];
 				break;
 			}
 		}
@@ -3977,7 +4046,7 @@ void TextServerAdvanced::shaped_text_overrun_trim_to_width(RID p_shaped_line, fl
 	}
 
 	int ell_min_characters = 6;
-	float width = sd->width;
+	double width = sd->width;
 
 	bool is_rtl = sd->para_direction == DIRECTION_RTL;
 
@@ -4063,7 +4132,7 @@ void TextServerAdvanced::shaped_text_overrun_trim_to_width(RID p_shaped_line, fl
 	}
 }
 
-int TextServerAdvanced::shaped_text_get_trim_pos(RID p_shaped) const {
+int64_t TextServerAdvanced::shaped_text_get_trim_pos(const RID &p_shaped) const {
 	ShapedTextDataAdvanced *sd = shaped_owner.get_or_null(p_shaped);
 	ERR_FAIL_COND_V_MSG(!sd, -1, "ShapedTextDataAdvanced invalid.");
 
@@ -4071,7 +4140,7 @@ int TextServerAdvanced::shaped_text_get_trim_pos(RID p_shaped) const {
 	return sd->overrun_trim_data.trim_pos;
 }
 
-int TextServerAdvanced::shaped_text_get_ellipsis_pos(RID p_shaped) const {
+int64_t TextServerAdvanced::shaped_text_get_ellipsis_pos(const RID &p_shaped) const {
 	ShapedTextDataAdvanced *sd = shaped_owner.get_or_null(p_shaped);
 	ERR_FAIL_COND_V_MSG(!sd, -1, "ShapedTextDataAdvanced invalid.");
 
@@ -4079,7 +4148,7 @@ int TextServerAdvanced::shaped_text_get_ellipsis_pos(RID p_shaped) const {
 	return sd->overrun_trim_data.ellipsis_pos;
 }
 
-const Glyph *TextServerAdvanced::shaped_text_get_ellipsis_glyphs(RID p_shaped) const {
+const Glyph *TextServerAdvanced::shaped_text_get_ellipsis_glyphs(const RID &p_shaped) const {
 	ShapedTextDataAdvanced *sd = shaped_owner.get_or_null(p_shaped);
 	ERR_FAIL_COND_V_MSG(!sd, nullptr, "ShapedTextDataAdvanced invalid.");
 
@@ -4087,7 +4156,7 @@ const Glyph *TextServerAdvanced::shaped_text_get_ellipsis_glyphs(RID p_shaped) c
 	return sd->overrun_trim_data.ellipsis_glyph_buf.ptr();
 }
 
-int TextServerAdvanced::shaped_text_get_ellipsis_glyph_count(RID p_shaped) const {
+int64_t TextServerAdvanced::shaped_text_get_ellipsis_glyph_count(const RID &p_shaped) const {
 	ShapedTextDataAdvanced *sd = shaped_owner.get_or_null(p_shaped);
 	ERR_FAIL_COND_V_MSG(!sd, 0, "ShapedTextDataAdvanced invalid.");
 
@@ -4095,7 +4164,7 @@ int TextServerAdvanced::shaped_text_get_ellipsis_glyph_count(RID p_shaped) const
 	return sd->overrun_trim_data.ellipsis_glyph_buf.size();
 }
 
-bool TextServerAdvanced::shaped_text_update_breaks(RID p_shaped) {
+bool TextServerAdvanced::shaped_text_update_breaks(const RID &p_shaped) {
 	ShapedTextDataAdvanced *sd = shaped_owner.get_or_null(p_shaped);
 	ERR_FAIL_COND_V(!sd, false);
 
@@ -4108,7 +4177,7 @@ bool TextServerAdvanced::shaped_text_update_breaks(RID p_shaped) {
 		return true; // Nothing to do.
 	}
 
-	const UChar *data = sd->utf16.ptr();
+	const UChar *data = sd->utf16.get_data();
 
 	if (!sd->break_ops_valid) {
 		sd->breaks.clear();
@@ -4171,7 +4240,7 @@ bool TextServerAdvanced::shaped_text_update_breaks(RID p_shaped) {
 				sd_glyphs[i].flags |= GRAPHEME_IS_SPACE;
 			}
 			if (c_punct_size == 0) {
-				if (u_ispunct(c) && c != 0x005F) {
+				if (u_ispunct(c) && c != 0x005f) {
 					sd_glyphs[i].flags |= GRAPHEME_IS_PUNCTUATION;
 				}
 			} else {
@@ -4237,10 +4306,10 @@ bool TextServerAdvanced::shaped_text_update_breaks(RID p_shaped) {
 	return sd->line_breaks_valid;
 }
 
-_FORCE_INLINE_ int _generate_kashida_justification_opportunies(const String &p_data, int p_start, int p_end) {
-	int kashida_pos = -1;
+_FORCE_INLINE_ int64_t _generate_kashida_justification_opportunies(const String &p_data, int64_t p_start, int64_t p_end) {
+	int64_t kashida_pos = -1;
 	int8_t priority = 100;
-	int i = p_start;
+	int64_t i = p_start;
 
 	char32_t pc = 0;
 
@@ -4256,7 +4325,7 @@ _FORCE_INLINE_ int _generate_kashida_justification_opportunies(const String &p_d
 			priority = 0;
 		}
 		if (priority >= 1 && i < p_end - 1) {
-			if (is_seen_sad(c) && (p_data[i + 1] != 0x200C)) {
+			if (is_seen_sad(c) && (p_data[i + 1] != 0x200c)) {
 				kashida_pos = i;
 				priority = 1;
 			}
@@ -4312,7 +4381,7 @@ _FORCE_INLINE_ int _generate_kashida_justification_opportunies(const String &p_d
 	return kashida_pos;
 }
 
-bool TextServerAdvanced::shaped_text_update_justification_ops(RID p_shaped) {
+bool TextServerAdvanced::shaped_text_update_justification_ops(const RID &p_shaped) {
 	ShapedTextDataAdvanced *sd = shaped_owner.get_or_null(p_shaped);
 	ERR_FAIL_COND_V(!sd, false);
 
@@ -4328,8 +4397,8 @@ bool TextServerAdvanced::shaped_text_update_justification_ops(RID p_shaped) {
 		return true; // Nothing to do.
 	}
 
-	const UChar *data = sd->utf16.ptr();
-	int32_t data_size = sd->utf16.length();
+	const UChar *data = sd->utf16.get_data();
+	int data_size = sd->utf16.length();
 
 	if (!sd->js_ops_valid) {
 		sd->jstops.clear();
@@ -4459,7 +4528,7 @@ bool TextServerAdvanced::shaped_text_update_justification_ops(RID p_shaped) {
 	return sd->justification_ops_valid;
 }
 
-Glyph TextServerAdvanced::_shape_single_glyph(ShapedTextDataAdvanced *p_sd, char32_t p_char, hb_script_t p_script, hb_direction_t p_direction, RID p_font, int p_font_size) {
+Glyph TextServerAdvanced::_shape_single_glyph(ShapedTextDataAdvanced *p_sd, char32_t p_char, hb_script_t p_script, hb_direction_t p_direction, const RID &p_font, int64_t p_font_size) {
 	hb_font_t *hb_font = _font_get_hb_handle(p_font, p_font_size);
 	bool subpos = (font_get_subpixel_positioning(p_font) == SUBPIXEL_POSITIONING_ONE_HALF) || (font_get_subpixel_positioning(p_font) == SUBPIXEL_POSITIONING_ONE_QUARTER) || (font_get_subpixel_positioning(p_font) == SUBPIXEL_POSITIONING_AUTO && p_font_size <= SUBPIXEL_POSITIONING_ONE_HALF_MAX_SIZE);
 	ERR_FAIL_COND_V(hb_font == nullptr, Glyph());
@@ -4487,7 +4556,7 @@ Glyph TextServerAdvanced::_shape_single_glyph(ShapedTextDataAdvanced *p_sd, char
 	gl.font_size = p_font_size;
 
 	if (glyph_count > 0) {
-		float scale = font_get_scale(p_font, p_font_size);
+		double scale = font_get_scale(p_font, p_font_size);
 		if (p_sd->orientation == ORIENTATION_HORIZONTAL) {
 			if (subpos) {
 				gl.advance = glyph_pos[0].x_advance / (64.0 / scale) + _get_extra_advance(p_font, p_font_size);
@@ -4515,16 +4584,18 @@ Glyph TextServerAdvanced::_shape_single_glyph(ShapedTextDataAdvanced *p_sd, char
 }
 
 _FORCE_INLINE_ void TextServerAdvanced::_add_featuers(const Dictionary &p_source, Vector<hb_feature_t> &r_ftrs) {
-	for (const Variant *ftr = p_source.next(nullptr); ftr != nullptr; ftr = p_source.next(ftr)) {
-		int32_t values = p_source[*ftr];
-		if (values >= 0) {
+	Array keys = p_source.keys();
+	Array values = p_source.values();
+	for (int i = 0; i < keys.size(); i++) {
+		int32_t value = values[i];
+		if (value >= 0) {
 			hb_feature_t feature;
-			if (ftr->get_type() == Variant::STRING) {
-				feature.tag = name_to_tag(*ftr);
+			if (keys[i].get_type() == Variant::STRING) {
+				feature.tag = name_to_tag(keys[i]);
 			} else {
-				feature.tag = *ftr;
+				feature.tag = keys[i];
 			}
-			feature.value = values;
+			feature.value = value;
 			feature.start = 0;
 			feature.end = -1;
 			r_ftrs.push_back(feature);
@@ -4532,7 +4603,7 @@ _FORCE_INLINE_ void TextServerAdvanced::_add_featuers(const Dictionary &p_source
 	}
 }
 
-void TextServerAdvanced::_shape_run(ShapedTextDataAdvanced *p_sd, int32_t p_start, int32_t p_end, hb_script_t p_script, hb_direction_t p_direction, Vector<RID> p_fonts, int p_span, int p_fb_index) {
+void TextServerAdvanced::_shape_run(ShapedTextDataAdvanced *p_sd, int64_t p_start, int64_t p_end, hb_script_t p_script, hb_direction_t p_direction, Array p_fonts, int64_t p_span, int64_t p_fb_index) {
 	int fs = p_sd->spans[p_span].font_size;
 	if (p_fb_index >= p_fonts.size()) {
 		// Add fallback glyphs.
@@ -4553,8 +4624,8 @@ void TextServerAdvanced::_shape_run(ShapedTextDataAdvanced *p_sd, int32_t p_star
 					p_sd->ascent = MAX(p_sd->ascent, get_hex_code_box_size(fs, gl.index).y);
 				} else {
 					gl.advance = get_hex_code_box_size(fs, gl.index).y;
-					p_sd->ascent = MAX(p_sd->ascent, Math::round(get_hex_code_box_size(fs, gl.index).x * 0.5f));
-					p_sd->descent = MAX(p_sd->descent, Math::round(get_hex_code_box_size(fs, gl.index).x * 0.5f));
+					p_sd->ascent = MAX(p_sd->ascent, Math::round(get_hex_code_box_size(fs, gl.index).x * 0.5));
+					p_sd->descent = MAX(p_sd->descent, Math::round(get_hex_code_box_size(fs, gl.index).x * 0.5));
 				}
 				p_sd->width += gl.advance;
 
@@ -4566,10 +4637,10 @@ void TextServerAdvanced::_shape_run(ShapedTextDataAdvanced *p_sd, int32_t p_star
 
 	RID f = p_fonts[p_fb_index];
 	hb_font_t *hb_font = _font_get_hb_handle(f, fs);
-	float scale = font_get_scale(f, fs);
-	float sp_sp = font_get_spacing(f, fs, SPACING_SPACE);
-	float sp_gl = font_get_spacing(f, fs, SPACING_GLYPH);
-	float ea = _get_extra_advance(f, fs);
+	double scale = font_get_scale(f, fs);
+	double sp_sp = font_get_spacing(f, fs, SPACING_SPACE);
+	double sp_gl = font_get_spacing(f, fs, SPACING_GLYPH);
+	double ea = _get_extra_advance(f, fs);
 	bool subpos = (font_get_subpixel_positioning(f) == SUBPIXEL_POSITIONING_ONE_HALF) || (font_get_subpixel_positioning(f) == SUBPIXEL_POSITIONING_ONE_QUARTER) || (font_get_subpixel_positioning(f) == SUBPIXEL_POSITIONING_AUTO && fs <= SUBPIXEL_POSITIONING_ONE_HALF_MAX_SIZE);
 	ERR_FAIL_COND(hb_font == nullptr);
 
@@ -4703,7 +4774,7 @@ void TextServerAdvanced::_shape_run(ShapedTextDataAdvanced *p_sd, int32_t p_star
 						p_sd->ascent = MAX(p_sd->ascent, -w[i + j].y_off);
 						p_sd->descent = MAX(p_sd->descent, w[i + j].y_off);
 					} else {
-						float gla = Math::round(font_get_glyph_advance(f, fs, w[i + j].index).x * 0.5);
+						double gla = Math::round(font_get_glyph_advance(f, fs, w[i + j].index).x * 0.5);
 						p_sd->ascent = MAX(p_sd->ascent, gla);
 						p_sd->descent = MAX(p_sd->descent, gla);
 					}
@@ -4733,7 +4804,7 @@ void TextServerAdvanced::_shape_run(ShapedTextDataAdvanced *p_sd, int32_t p_star
 	}
 }
 
-bool TextServerAdvanced::shaped_text_shape(RID p_shaped) {
+bool TextServerAdvanced::shaped_text_shape(const RID &p_shaped) {
 	ShapedTextDataAdvanced *sd = shaped_owner.get_or_null(p_shaped);
 	ERR_FAIL_COND_V(!sd, false);
 
@@ -4757,7 +4828,7 @@ bool TextServerAdvanced::shaped_text_shape(RID p_shaped) {
 	}
 
 	sd->utf16 = sd->text.utf16();
-	const UChar *data = sd->utf16.ptr();
+	const UChar *data = sd->utf16.get_data();
 
 	// Create script iterator.
 	if (sd->script_iter == nullptr) {
@@ -4876,9 +4947,9 @@ bool TextServerAdvanced::shaped_text_shape(RID p_shaped) {
 							}
 							sd->glyphs.push_back(gl);
 						} else {
-							Vector<RID> fonts;
-							Vector<RID> fonts_scr_only;
-							Vector<RID> fonts_no_match;
+							Array fonts;
+							Array fonts_scr_only;
+							Array fonts_no_match;
 							int font_count = span.fonts.size();
 							for (int l = 0; l < font_count; l++) {
 								if (font_is_script_supported(span.fonts[l], script)) {
@@ -4906,7 +4977,7 @@ bool TextServerAdvanced::shaped_text_shape(RID p_shaped) {
 	return sd->valid;
 }
 
-bool TextServerAdvanced::shaped_text_is_ready(RID p_shaped) const {
+bool TextServerAdvanced::shaped_text_is_ready(const RID &p_shaped) const {
 	const ShapedTextDataAdvanced *sd = shaped_owner.get_or_null(p_shaped);
 	ERR_FAIL_COND_V(!sd, false);
 
@@ -4914,7 +4985,7 @@ bool TextServerAdvanced::shaped_text_is_ready(RID p_shaped) const {
 	return sd->valid;
 }
 
-const Glyph *TextServerAdvanced::shaped_text_get_glyphs(RID p_shaped) const {
+const Glyph *TextServerAdvanced::shaped_text_get_glyphs(const RID &p_shaped) const {
 	const ShapedTextDataAdvanced *sd = shaped_owner.get_or_null(p_shaped);
 	ERR_FAIL_COND_V(!sd, nullptr);
 
@@ -4925,7 +4996,7 @@ const Glyph *TextServerAdvanced::shaped_text_get_glyphs(RID p_shaped) const {
 	return sd->glyphs.ptr();
 }
 
-int TextServerAdvanced::shaped_text_get_glyph_count(RID p_shaped) const {
+int64_t TextServerAdvanced::shaped_text_get_glyph_count(const RID &p_shaped) const {
 	const ShapedTextDataAdvanced *sd = shaped_owner.get_or_null(p_shaped);
 	ERR_FAIL_COND_V(!sd, 0);
 
@@ -4936,7 +5007,7 @@ int TextServerAdvanced::shaped_text_get_glyph_count(RID p_shaped) const {
 	return sd->glyphs.size();
 }
 
-const Glyph *TextServerAdvanced::shaped_text_sort_logical(RID p_shaped) {
+const Glyph *TextServerAdvanced::shaped_text_sort_logical(const RID &p_shaped) {
 	ShapedTextDataAdvanced *sd = shaped_owner.get_or_null(p_shaped);
 	ERR_FAIL_COND_V(!sd, nullptr);
 
@@ -4954,7 +5025,7 @@ const Glyph *TextServerAdvanced::shaped_text_sort_logical(RID p_shaped) {
 	return sd->glyphs_logical.ptr();
 }
 
-Vector2i TextServerAdvanced::shaped_text_get_range(RID p_shaped) const {
+Vector2i TextServerAdvanced::shaped_text_get_range(const RID &p_shaped) const {
 	const ShapedTextDataAdvanced *sd = shaped_owner.get_or_null(p_shaped);
 	ERR_FAIL_COND_V(!sd, Vector2i());
 
@@ -4962,7 +5033,7 @@ Vector2i TextServerAdvanced::shaped_text_get_range(RID p_shaped) const {
 	return Vector2(sd->start, sd->end);
 }
 
-Array TextServerAdvanced::shaped_text_get_objects(RID p_shaped) const {
+Array TextServerAdvanced::shaped_text_get_objects(const RID &p_shaped) const {
 	Array ret;
 	const ShapedTextDataAdvanced *sd = shaped_owner.get_or_null(p_shaped);
 	ERR_FAIL_COND_V(!sd, ret);
@@ -4975,7 +5046,7 @@ Array TextServerAdvanced::shaped_text_get_objects(RID p_shaped) const {
 	return ret;
 }
 
-Rect2 TextServerAdvanced::shaped_text_get_object_rect(RID p_shaped, Variant p_key) const {
+Rect2 TextServerAdvanced::shaped_text_get_object_rect(const RID &p_shaped, const Variant &p_key) const {
 	const ShapedTextDataAdvanced *sd = shaped_owner.get_or_null(p_shaped);
 	ERR_FAIL_COND_V(!sd, Rect2());
 
@@ -4987,7 +5058,7 @@ Rect2 TextServerAdvanced::shaped_text_get_object_rect(RID p_shaped, Variant p_ke
 	return sd->objects[p_key].rect;
 }
 
-Size2 TextServerAdvanced::shaped_text_get_size(RID p_shaped) const {
+Size2 TextServerAdvanced::shaped_text_get_size(const RID &p_shaped) const {
 	const ShapedTextDataAdvanced *sd = shaped_owner.get_or_null(p_shaped);
 	ERR_FAIL_COND_V(!sd, Size2());
 
@@ -5002,9 +5073,9 @@ Size2 TextServerAdvanced::shaped_text_get_size(RID p_shaped) const {
 	}
 }
 
-float TextServerAdvanced::shaped_text_get_ascent(RID p_shaped) const {
+double TextServerAdvanced::shaped_text_get_ascent(const RID &p_shaped) const {
 	const ShapedTextDataAdvanced *sd = shaped_owner.get_or_null(p_shaped);
-	ERR_FAIL_COND_V(!sd, 0.f);
+	ERR_FAIL_COND_V(!sd, 0.0);
 
 	MutexLock lock(sd->mutex);
 	if (!sd->valid) {
@@ -5013,9 +5084,9 @@ float TextServerAdvanced::shaped_text_get_ascent(RID p_shaped) const {
 	return sd->ascent;
 }
 
-float TextServerAdvanced::shaped_text_get_descent(RID p_shaped) const {
+double TextServerAdvanced::shaped_text_get_descent(const RID &p_shaped) const {
 	const ShapedTextDataAdvanced *sd = shaped_owner.get_or_null(p_shaped);
-	ERR_FAIL_COND_V(!sd, 0.f);
+	ERR_FAIL_COND_V(!sd, 0.0);
 
 	MutexLock lock(sd->mutex);
 	if (!sd->valid) {
@@ -5024,9 +5095,9 @@ float TextServerAdvanced::shaped_text_get_descent(RID p_shaped) const {
 	return sd->descent;
 }
 
-float TextServerAdvanced::shaped_text_get_width(RID p_shaped) const {
+double TextServerAdvanced::shaped_text_get_width(const RID &p_shaped) const {
 	const ShapedTextDataAdvanced *sd = shaped_owner.get_or_null(p_shaped);
-	ERR_FAIL_COND_V(!sd, 0.f);
+	ERR_FAIL_COND_V(!sd, 0.0);
 
 	MutexLock lock(sd->mutex);
 	if (!sd->valid) {
@@ -5035,9 +5106,9 @@ float TextServerAdvanced::shaped_text_get_width(RID p_shaped) const {
 	return Math::ceil(sd->text_trimmed ? sd->width_trimmed : sd->width);
 }
 
-float TextServerAdvanced::shaped_text_get_underline_position(RID p_shaped) const {
+double TextServerAdvanced::shaped_text_get_underline_position(const RID &p_shaped) const {
 	const ShapedTextDataAdvanced *sd = shaped_owner.get_or_null(p_shaped);
-	ERR_FAIL_COND_V(!sd, 0.f);
+	ERR_FAIL_COND_V(!sd, 0.0);
 
 	MutexLock lock(sd->mutex);
 	if (!sd->valid) {
@@ -5047,9 +5118,9 @@ float TextServerAdvanced::shaped_text_get_underline_position(RID p_shaped) const
 	return sd->upos;
 }
 
-float TextServerAdvanced::shaped_text_get_underline_thickness(RID p_shaped) const {
+double TextServerAdvanced::shaped_text_get_underline_thickness(const RID &p_shaped) const {
 	const ShapedTextDataAdvanced *sd = shaped_owner.get_or_null(p_shaped);
-	ERR_FAIL_COND_V(!sd, 0.f);
+	ERR_FAIL_COND_V(!sd, 0.0);
 
 	MutexLock lock(sd->mutex);
 	if (!sd->valid) {
@@ -5246,7 +5317,7 @@ String TextServerAdvanced::format_number(const String &p_string, const String &p
 			res.replace("e", num_systems[i].exp);
 			res.replace("E", num_systems[i].exp);
 			char32_t *data = res.ptrw();
-			for (int j = 0; j < res.size(); j++) {
+			for (int j = 0; j < res.length(); j++) {
 				if (data[j] >= 0x30 && data[j] <= 0x39) {
 					data[j] = num_systems[i].digits[data[j] - 0x30];
 				} else if (data[j] == '.' || data[j] == ',') {
@@ -5270,7 +5341,7 @@ String TextServerAdvanced::parse_number(const String &p_string, const String &p_
 			}
 			res.replace(num_systems[i].exp, "e");
 			char32_t *data = res.ptrw();
-			for (int j = 0; j < res.size(); j++) {
+			for (int j = 0; j < res.length(); j++) {
 				if (data[j] == num_systems[i].digits[10]) {
 					data[j] = '.';
 				} else {
@@ -5312,13 +5383,13 @@ String TextServerAdvanced::strip_diacritics(const String &p_string) const {
 	Char16String utf16 = p_string.utf16();
 
 	// Normalize.
-	Char16String normalized;
+	Vector<char16_t> normalized;
 	err = U_ZERO_ERROR;
-	int32_t len = unorm2_normalize(unorm, utf16.ptr(), -1, nullptr, 0, &err);
+	int32_t len = unorm2_normalize(unorm, utf16.get_data(), -1, nullptr, 0, &err);
 	ERR_FAIL_COND_V_MSG(err != U_BUFFER_OVERFLOW_ERROR, TextServer::strip_diacritics(p_string), u_errorName(err));
 	normalized.resize(len);
 	err = U_ZERO_ERROR;
-	unorm2_normalize(unorm, utf16.ptr(), -1, normalized.ptrw(), len, &err);
+	unorm2_normalize(unorm, utf16.get_data(), -1, normalized.ptrw(), len, &err);
 	ERR_FAIL_COND_V_MSG(U_FAILURE(err), TextServer::strip_diacritics(p_string), u_errorName(err));
 
 	// Convert back to UTF-32.
@@ -5328,7 +5399,7 @@ String TextServerAdvanced::strip_diacritics(const String &p_string) const {
 	String result;
 	for (int i = 0; i < normalized_string.length(); i++) {
 		if (u_getCombiningClass(normalized_string[i]) == 0) {
-			result += normalized_string[i];
+			result = result + normalized_string[i];
 		}
 	}
 	return result;
@@ -5338,13 +5409,13 @@ String TextServerAdvanced::string_to_upper(const String &p_string, const String
 	// Convert to UTF-16.
 	Char16String utf16 = p_string.utf16();
 
-	Char16String upper;
+	Vector<char16_t> upper;
 	UErrorCode err = U_ZERO_ERROR;
-	int32_t len = u_strToUpper(nullptr, 0, utf16.ptr(), -1, p_language.ascii().get_data(), &err);
+	int32_t len = u_strToUpper(nullptr, 0, utf16.get_data(), -1, p_language.ascii().get_data(), &err);
 	ERR_FAIL_COND_V_MSG(err != U_BUFFER_OVERFLOW_ERROR, p_string, u_errorName(err));
 	upper.resize(len);
 	err = U_ZERO_ERROR;
-	u_strToUpper(upper.ptrw(), len, utf16.ptr(), -1, p_language.ascii().get_data(), &err);
+	u_strToUpper(upper.ptrw(), len, utf16.get_data(), -1, p_language.ascii().get_data(), &err);
 	ERR_FAIL_COND_V_MSG(U_FAILURE(err), p_string, u_errorName(err));
 
 	// Convert back to UTF-32.
@@ -5355,13 +5426,13 @@ String TextServerAdvanced::string_to_lower(const String &p_string, const String
 	// Convert to UTF-16.
 	Char16String utf16 = p_string.utf16();
 
-	Char16String lower;
+	Vector<char16_t> lower;
 	UErrorCode err = U_ZERO_ERROR;
-	int32_t len = u_strToLower(nullptr, 0, utf16.ptr(), -1, p_language.ascii().get_data(), &err);
+	int32_t len = u_strToLower(nullptr, 0, utf16.get_data(), -1, p_language.ascii().get_data(), &err);
 	ERR_FAIL_COND_V_MSG(err != U_BUFFER_OVERFLOW_ERROR, p_string, u_errorName(err));
 	lower.resize(len);
 	err = U_ZERO_ERROR;
-	u_strToLower(lower.ptrw(), len, utf16.ptr(), -1, p_language.ascii().get_data(), &err);
+	u_strToLower(lower.ptrw(), len, utf16.get_data(), -1, p_language.ascii().get_data(), &err);
 	ERR_FAIL_COND_V_MSG(U_FAILURE(err), p_string, u_errorName(err));
 
 	// Convert back to UTF-32.
@@ -5376,14 +5447,8 @@ TextServerAdvanced::TextServerAdvanced() {
 
 TextServerAdvanced::~TextServerAdvanced() {
 	_bmp_free_font_funcs();
-	if (library != nullptr) {
-		FT_Done_FreeType(library);
+	if (ft_library != nullptr) {
+		FT_Done_FreeType(ft_library);
 	}
 	u_cleanup();
-#ifndef ICU_STATIC_DATA
-	if (icu_data != nullptr) {
-		memfree(icu_data);
-		icu_data = nullptr;
-	}
-#endif
 }
diff --git a/modules/text_server_adv/text_server_adv.h b/modules/text_server_adv/text_server_adv.h
index e5958fc162..bb3968ee3f 100644
--- a/modules/text_server_adv/text_server_adv.h
+++ b/modules/text_server_adv/text_server_adv.h
@@ -36,13 +36,61 @@
 /* shaping and advanced font features support.                           */
 /*************************************************************************/
 
-#include "servers/text_server.h"
+#ifdef GDEXTENSION
+// Headers for building as GDExtension plug-in.
+
+#include <godot_cpp/godot.hpp>
+
+#include <godot_cpp/core/class_db.hpp>
+#include <godot_cpp/core/mutex_lock.hpp>
+
+#include <godot_cpp/variant/array.hpp>
+#include <godot_cpp/variant/dictionary.hpp>
+#include <godot_cpp/variant/packed_int32_array.hpp>
+#include <godot_cpp/variant/packed_string_array.hpp>
+#include <godot_cpp/variant/packed_vector2_array.hpp>
+#include <godot_cpp/variant/rect2.hpp>
+#include <godot_cpp/variant/rid.hpp>
+#include <godot_cpp/variant/string.hpp>
+#include <godot_cpp/variant/vector2.hpp>
+#include <godot_cpp/variant/vector2i.hpp>
+
+#include <godot_cpp/classes/text_server.hpp>
+#include <godot_cpp/classes/text_server_extension.hpp>
+#include <godot_cpp/classes/text_server_manager.hpp>
+
+#include <godot_cpp/classes/caret_info.hpp>
+#include <godot_cpp/classes/global_constants_binds.hpp>
+#include <godot_cpp/classes/glyph.hpp>
+#include <godot_cpp/classes/image.hpp>
+#include <godot_cpp/classes/image_texture.hpp>
+#include <godot_cpp/classes/ref.hpp>
+
+#include <godot_cpp/templates/hash_map.hpp>
+#include <godot_cpp/templates/map.hpp>
+#include <godot_cpp/templates/rid_owner.hpp>
+#include <godot_cpp/templates/set.hpp>
+#include <godot_cpp/templates/thread_work_pool.hpp>
+#include <godot_cpp/templates/vector.hpp>
+
+using namespace godot;
+
+#else
+// Headers for building as built-in module.
 
 #include "core/templates/rid_owner.h"
 #include "core/templates/thread_work_pool.h"
 #include "scene/resources/texture.h"
+#include "servers/text/text_server_extension.h"
+
+#include "modules/modules_enabled.gen.h" // For freetype, msdfgen.
+
+#endif
+
 #include "script_iterator.h"
 
+// Thirdparty headers.
+
 #include <unicode/ubidi.h>
 #include <unicode/ubrk.h>
 #include <unicode/uchar.h>
@@ -55,8 +103,6 @@
 #include <unicode/ustring.h>
 #include <unicode/utypes.h>
 
-#include "modules/modules_enabled.gen.h" // For freetype, msdfgen.
-
 #ifdef MODULE_FREETYPE_ENABLED
 #include <ft2build.h>
 #include FT_FREETYPE_H
@@ -73,12 +119,11 @@
 #include <hb-icu.h>
 #include <hb.h>
 
-class TextServerAdvanced : public TextServer {
-	GDCLASS(TextServerAdvanced, TextServer);
-	_THREAD_SAFE_CLASS_
+/*************************************************************************/
 
-	static String interface_name;
-	static uint32_t interface_features;
+class TextServerAdvanced : public TextServerExtension {
+	GDCLASS(TextServerAdvanced, TextServerExtension);
+	_THREAD_SAFE_CLASS_
 
 	struct NumSystemData {
 		Set<StringName> lang;
@@ -89,21 +134,23 @@ class TextServerAdvanced : public TextServer {
 
 	Vector<NumSystemData> num_systems;
 	Map<StringName, int32_t> feature_sets;
+	Map<int32_t, StringName> feature_sets_inv;
 
 	void _insert_num_systems_lang();
 	void _insert_feature_sets();
+	_FORCE_INLINE_ void _insert_feature(const StringName &p_name, int32_t p_tag);
 
 	// ICU support data.
 
-	uint8_t *icu_data = nullptr;
+	bool icu_data_loaded = false;
 
 	// Font cache data.
 
 #ifdef MODULE_FREETYPE_ENABLED
-	mutable FT_Library library = nullptr;
+	mutable FT_Library ft_library = nullptr;
 #endif
 
-	const int rect_range = 2;
+	const int rect_range = 1;
 
 	struct FontTexture {
 		Image::Format format;
@@ -129,12 +176,12 @@ class TextServerAdvanced : public TextServer {
 	};
 
 	struct FontDataForSizeAdvanced {
-		float ascent = 0.f;
-		float descent = 0.f;
-		float underline_position = 0.f;
-		float underline_thickness = 0.f;
-		float scale = 1.f;
-		float oversampling = 1.f;
+		double ascent = 0.0;
+		double descent = 0.0;
+		double underline_position = 0.0;
+		double underline_thickness = 0.0;
+		double scale = 1.0;
+		double oversampling = 1.0;
 
 		int spacing_glyph = 0;
 		int spacing_space = 0;
@@ -176,8 +223,8 @@ class TextServerAdvanced : public TextServer {
 		TextServer::Hinting hinting = TextServer::HINTING_LIGHT;
 		TextServer::SubpixelPositioning subpixel_positioning = TextServer::SUBPIXEL_POSITIONING_AUTO;
 		Dictionary variation_coordinates;
-		float oversampling = 0.f;
-		float embolden = 0.f;
+		double oversampling = 0.0;
+		double embolden = 0.0;
 		Transform2D transform;
 
 		uint32_t style_flags = 0;
@@ -203,8 +250,8 @@ class TextServerAdvanced : public TextServer {
 
 		~FontDataAdvanced() {
 			work_pool.finish();
-			for (const Map<Vector2i, FontDataForSizeAdvanced *>::Element *E = cache.front(); E; E = E->next()) {
-				memdelete(E->get());
+			for (const KeyValue<Vector2i, FontDataForSizeAdvanced *> &E : cache) {
+				memdelete(E.value);
 			}
 			cache.clear();
 		}
@@ -242,16 +289,34 @@ class TextServerAdvanced : public TextServer {
 		}
 	}
 
-	_FORCE_INLINE_ float _get_extra_advance(RID p_font_rid, int p_font_size) const;
+	_FORCE_INLINE_ double _get_extra_advance(RID p_font_rid, int p_font_size) const;
 
 	// Shaped text cache data.
+	struct TrimData {
+		int trim_pos = -1;
+		int ellipsis_pos = -1;
+		Vector<Glyph> ellipsis_glyph_buf;
+	};
+
+	struct ShapedTextDataAdvanced {
+		Mutex mutex;
+
+		/* Source data */
+		RID parent; // Substring parent ShapedTextData.
+
+		int start = 0; // Substring start offset in the parent string.
+		int end = 0; // Substring end offset in the parent string.
+
+		String text;
+		String custom_punct;
+		TextServer::Direction direction = DIRECTION_LTR; // Desired text direction.
+		TextServer::Orientation orientation = ORIENTATION_HORIZONTAL;
 
-	struct ShapedTextDataAdvanced : public ShapedTextData {
 		struct Span {
 			int start = -1;
 			int end = -1;
 
-			Vector<RID> fonts;
+			Array fonts;
 			int font_size = 0;
 
 			Variant embedded_key;
@@ -262,6 +327,38 @@ class TextServerAdvanced : public TextServer {
 		};
 		Vector<Span> spans;
 
+		struct EmbeddedObject {
+			int pos = 0;
+			InlineAlignment inline_align = INLINE_ALIGNMENT_CENTER;
+			Rect2 rect;
+		};
+		Map<Variant, EmbeddedObject> objects;
+
+		/* Shaped data */
+		TextServer::Direction para_direction = DIRECTION_LTR; // Detected text direction.
+		bool valid = false; // String is shaped.
+		bool line_breaks_valid = false; // Line and word break flags are populated (and virtual zero width spaces inserted).
+		bool justification_ops_valid = false; // Virtual elongation glyphs are added to the string.
+		bool sort_valid = false;
+		bool text_trimmed = false;
+
+		bool preserve_invalid = true; // Draw hex code box instead of missing characters.
+		bool preserve_control = false; // Draw control characters.
+
+		double ascent = 0.0; // Ascent for horizontal layout, 1/2 of width for vertical.
+		double descent = 0.0; // Descent for horizontal layout, 1/2 of width for vertical.
+		double width = 0.0; // Width for horizontal layout, height for vertical.
+		double width_trimmed = 0.0;
+
+		double upos = 0.0;
+		double uthk = 0.0;
+
+		TrimData overrun_trim_data;
+		bool fit_width_minimum_reached = false;
+
+		Vector<Glyph> glyphs;
+		Vector<Glyph> glyphs_logical;
+
 		/* Intermediate data */
 		Char16String utf16;
 		Vector<UBiDi *> bidi_iter;
@@ -289,16 +386,16 @@ class TextServerAdvanced : public TextServer {
 
 	// Common data.
 
-	float oversampling = 1.f;
+	double oversampling = 1.0;
 	mutable RID_PtrOwner<FontDataAdvanced> font_owner;
 	mutable RID_PtrOwner<ShapedTextDataAdvanced> shaped_owner;
 
 	void _realign(ShapedTextDataAdvanced *p_sd) const;
-	int _convert_pos(const ShapedTextDataAdvanced *p_sd, int p_pos) const;
-	int _convert_pos_inv(const ShapedTextDataAdvanced *p_sd, int p_pos) const;
-	bool _shape_substr(ShapedTextDataAdvanced *p_new_sd, const ShapedTextDataAdvanced *p_sd, int p_start, int p_length) const;
-	void _shape_run(ShapedTextDataAdvanced *p_sd, int32_t p_start, int32_t p_end, hb_script_t p_script, hb_direction_t p_direction, Vector<RID> p_fonts, int p_span, int p_fb_index);
-	Glyph _shape_single_glyph(ShapedTextDataAdvanced *p_sd, char32_t p_char, hb_script_t p_script, hb_direction_t p_direction, RID p_font, int p_font_size);
+	int64_t _convert_pos(const ShapedTextDataAdvanced *p_sd, int64_t p_pos) const;
+	int64_t _convert_pos_inv(const ShapedTextDataAdvanced *p_sd, int64_t p_pos) const;
+	bool _shape_substr(ShapedTextDataAdvanced *p_new_sd, const ShapedTextDataAdvanced *p_sd, int64_t p_start, int64_t p_length) const;
+	void _shape_run(ShapedTextDataAdvanced *p_sd, int64_t p_start, int64_t p_end, hb_script_t p_script, hb_direction_t p_direction, Array p_fonts, int64_t p_span, int64_t p_fb_index);
+	Glyph _shape_single_glyph(ShapedTextDataAdvanced *p_sd, char32_t p_char, hb_script_t p_script, hb_direction_t p_direction, const RID &p_font, int64_t p_font_size);
 	_FORCE_INLINE_ void _add_featuers(const Dictionary &p_source, Vector<hb_feature_t> &r_ftrs);
 
 	// HarfBuzz bitmap font interface.
@@ -324,6 +421,25 @@ class TextServerAdvanced : public TextServer {
 	static void _bmp_font_set_funcs(hb_font_t *p_font, TextServerAdvanced::FontDataForSizeAdvanced *p_face, bool p_unref);
 	static hb_font_t *_bmp_font_create(TextServerAdvanced::FontDataForSizeAdvanced *p_face, hb_destroy_func_t p_destroy);
 
+	hb_font_t *_font_get_hb_handle(const RID &p_font, int64_t p_font_size) const;
+
+	struct GlyphCompare { // For line breaking reordering.
+		_FORCE_INLINE_ bool operator()(const Glyph &l, const Glyph &r) const {
+			if (l.start == r.start) {
+				if (l.count == r.count) {
+					if ((l.flags & TextServer::GRAPHEME_IS_VIRTUAL) == TextServer::GRAPHEME_IS_VIRTUAL) {
+						return false;
+					} else {
+						return true;
+					}
+				}
+				return l.count > r.count; // Sort first glyph with count & flags, order of the rest are irrelevant.
+			} else {
+				return l.start < r.start;
+			}
+		}
+	};
+
 protected:
 	static void _bind_methods(){};
 
@@ -333,10 +449,10 @@ protected:
 public:
 	virtual bool has_feature(Feature p_feature) const override;
 	virtual String get_name() const override;
-	virtual uint32_t get_features() const override;
+	virtual int64_t get_features() const override;
 
-	virtual void free(RID p_rid) override;
-	virtual bool has(RID p_rid) override;
+	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;
 
 	virtual String get_support_data_filename() const override;
@@ -345,220 +461,218 @@ public:
 
 	virtual bool is_locale_right_to_left(const String &p_locale) const override;
 
-	virtual int32_t name_to_tag(const String &p_name) const override;
-	virtual String tag_to_name(int32_t p_tag) const override;
+	virtual int64_t name_to_tag(const String &p_name) const override;
+	virtual String tag_to_name(int64_t p_tag) const override;
 
 	/* Font interface */
 	virtual RID create_font() override;
 
-	virtual void font_set_data(RID p_font_rid, const PackedByteArray &p_data) override;
-	virtual void font_set_data_ptr(RID p_font_rid, const uint8_t *p_data_ptr, size_t p_data_size) override;
-
-	virtual void font_set_style(RID p_font_rid, uint32_t /*FontStyle*/ p_style) override;
-	virtual uint32_t /*FontStyle*/ font_get_style(RID p_font_rid) const 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;
 
-	virtual void font_set_style_name(RID p_font_rid, const String &p_name) override;
-	virtual String font_get_style_name(RID p_font_rid) const override;
+	virtual void font_set_style(const RID &p_font_rid, int64_t /*FontStyle*/ p_style) override;
+	virtual int64_t /*FontStyle*/ font_get_style(const RID &p_font_rid) const override;
 
-	virtual void font_set_name(RID p_font_rid, const String &p_name) override;
-	virtual String font_get_name(RID p_font_rid) const override;
+	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;
 
-	virtual void font_set_antialiased(RID p_font_rid, bool p_antialiased) override;
-	virtual bool font_is_antialiased(RID p_font_rid) const override;
+	virtual void font_set_name(const RID &p_font_rid, const String &p_name) override;
+	virtual String font_get_name(const RID &p_font_rid) const override;
 
-	virtual void font_set_multichannel_signed_distance_field(RID p_font_rid, bool p_msdf) override;
-	virtual bool font_is_multichannel_signed_distance_field(RID p_font_rid) const override;
+	virtual void font_set_antialiased(const RID &p_font_rid, bool p_antialiased) override;
+	virtual bool font_is_antialiased(const RID &p_font_rid) const override;
 
-	virtual void font_set_msdf_pixel_range(RID p_font_rid, int p_msdf_pixel_range) override;
-	virtual int font_get_msdf_pixel_range(RID p_font_rid) const override;
+	virtual void font_set_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;
 
-	virtual void font_set_msdf_size(RID p_font_rid, int p_msdf_size) override;
-	virtual int font_get_msdf_size(RID p_font_rid) const override;
+	virtual void font_set_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;
 
-	virtual void font_set_fixed_size(RID p_font_rid, int p_fixed_size) override;
-	virtual int font_get_fixed_size(RID p_font_rid) const override;
+	virtual void font_set_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;
 
-	virtual void font_set_force_autohinter(RID p_font_rid, bool p_force_autohinter) override;
-	virtual bool font_is_force_autohinter(RID p_font_rid) const override;
+	virtual void font_set_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;
 
-	virtual void font_set_hinting(RID p_font_rid, TextServer::Hinting p_hinting) override;
-	virtual TextServer::Hinting font_get_hinting(RID p_font_rid) const override;
+	virtual void font_set_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;
 
-	virtual void font_set_subpixel_positioning(RID p_font_rid, SubpixelPositioning p_subpixel) override;
-	virtual SubpixelPositioning font_get_subpixel_positioning(RID p_font_rid) const override;
+	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;
 
-	virtual void font_set_embolden(RID p_font_rid, float p_strength) override;
-	virtual float font_get_embolden(RID p_font_rid) const override;
+	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;
 
-	virtual void font_set_transform(RID p_font_rid, Transform2D p_transform) override;
-	virtual Transform2D font_get_transform(RID p_font_rid) const override;
+	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;
 
-	virtual void font_set_variation_coordinates(RID p_font_rid, const Dictionary &p_variation_coordinates) override;
-	virtual Dictionary font_get_variation_coordinates(RID p_font_rid) const override;
+	virtual void font_set_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;
 
-	virtual void font_set_oversampling(RID p_font_rid, float p_oversampling) override;
-	virtual float font_get_oversampling(RID p_font_rid) const override;
+	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;
 
-	virtual Array font_get_size_cache_list(RID p_font_rid) const override;
-	virtual void font_clear_size_cache(RID p_font_rid) override;
-	virtual void font_remove_size_cache(RID p_font_rid, const Vector2i &p_size) override;
+	virtual void font_set_oversampling(const RID &p_font_rid, double p_oversampling) override;
+	virtual double font_get_oversampling(const RID &p_font_rid) const override;
 
-	hb_font_t *_font_get_hb_handle(RID p_font, int p_font_size) const;
+	virtual Array 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;
 
-	virtual void font_set_ascent(RID p_font_rid, int p_size, float p_ascent) override;
-	virtual float font_get_ascent(RID p_font_rid, int p_size) const override;
+	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;
 
-	virtual void font_set_descent(RID p_font_rid, int p_size, float p_descent) override;
-	virtual float font_get_descent(RID p_font_rid, int p_size) const override;
+	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;
 
-	virtual void font_set_underline_position(RID p_font_rid, int p_size, float p_underline_position) override;
-	virtual float font_get_underline_position(RID p_font_rid, int p_size) const override;
+	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;
 
-	virtual void font_set_underline_thickness(RID p_font_rid, int p_size, float p_underline_thickness) override;
-	virtual float font_get_underline_thickness(RID p_font_rid, int p_size) const override;
+	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;
 
-	virtual void font_set_scale(RID p_font_rid, int p_size, float p_scale) override;
-	virtual float font_get_scale(RID p_font_rid, int p_size) const override;
+	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;
 
-	virtual void font_set_spacing(RID p_font_rid, int p_size, SpacingType p_spacing, int p_value) override;
-	virtual int font_get_spacing(RID p_font_rid, int p_size, SpacingType p_spacing) const override;
+	virtual void font_set_spacing(const RID &p_font_rid, int64_t p_size, SpacingType p_spacing, int64_t p_value) override;
+	virtual int64_t font_get_spacing(const RID &p_font_rid, int64_t p_size, SpacingType p_spacing) const override;
 
-	virtual int font_get_texture_count(RID p_font_rid, const Vector2i &p_size) const override;
-	virtual void font_clear_textures(RID p_font_rid, const Vector2i &p_size) override;
-	virtual void font_remove_texture(RID p_font_rid, const Vector2i &p_size, int p_texture_index) override;
+	virtual 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;
 
-	virtual void font_set_texture_image(RID p_font_rid, const Vector2i &p_size, int p_texture_index, const Ref<Image> &p_image) override;
-	virtual Ref<Image> font_get_texture_image(RID p_font_rid, const Vector2i &p_size, int p_texture_index) const override;
+	virtual void font_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;
 
-	virtual void font_set_texture_offsets(RID p_font_rid, const Vector2i &p_size, int p_texture_index, const PackedInt32Array &p_offset) override;
-	virtual PackedInt32Array font_get_texture_offsets(RID p_font_rid, const Vector2i &p_size, int p_texture_index) const override;
+	virtual 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;
 
-	virtual Array font_get_glyph_list(RID p_font_rid, const Vector2i &p_size) const override;
-	virtual void font_clear_glyphs(RID p_font_rid, const Vector2i &p_size) override;
-	virtual void font_remove_glyph(RID p_font_rid, const Vector2i &p_size, int32_t p_glyph) override;
+	virtual Array 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;
 
-	virtual Vector2 font_get_glyph_advance(RID p_font_rid, int p_size, int32_t p_glyph) const override;
-	virtual void font_set_glyph_advance(RID p_font_rid, int p_size, int32_t p_glyph, const Vector2 &p_advance) override;
+	virtual 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;
 
-	virtual Vector2 font_get_glyph_offset(RID p_font_rid, const Vector2i &p_size, int32_t p_glyph) const override;
-	virtual void font_set_glyph_offset(RID p_font_rid, const Vector2i &p_size, int32_t p_glyph, const Vector2 &p_offset) override;
+	virtual 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;
 
-	virtual Vector2 font_get_glyph_size(RID p_font_rid, const Vector2i &p_size, int32_t p_glyph) const override;
-	virtual void font_set_glyph_size(RID p_font_rid, const Vector2i &p_size, int32_t p_glyph, const Vector2 &p_gl_size) override;
+	virtual 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;
 
-	virtual Rect2 font_get_glyph_uv_rect(RID p_font_rid, const Vector2i &p_size, int32_t p_glyph) const override;
-	virtual void font_set_glyph_uv_rect(RID p_font_rid, const Vector2i &p_size, int32_t p_glyph, const Rect2 &p_uv_rect) override;
+	virtual 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;
 
-	virtual int font_get_glyph_texture_idx(RID p_font_rid, const Vector2i &p_size, int32_t p_glyph) const override;
-	virtual void font_set_glyph_texture_idx(RID p_font_rid, const Vector2i &p_size, int32_t p_glyph, int p_texture_idx) override;
+	virtual 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 Dictionary font_get_glyph_contours(RID p_font, int p_size, int32_t p_index) const override;
+	virtual Dictionary font_get_glyph_contours(const RID &p_font, int64_t p_size, int64_t p_index) const override;
 
-	virtual Array font_get_kerning_list(RID p_font_rid, int p_size) const override;
-	virtual void font_clear_kerning_map(RID p_font_rid, int p_size) override;
-	virtual void font_remove_kerning(RID p_font_rid, int p_size, const Vector2i &p_glyph_pair) override;
+	virtual Array 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;
 
-	virtual void font_set_kerning(RID p_font_rid, int p_size, const Vector2i &p_glyph_pair, const Vector2 &p_kerning) override;
-	virtual Vector2 font_get_kerning(RID p_font_rid, int p_size, const Vector2i &p_glyph_pair) const override;
+	virtual 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;
 
-	virtual int32_t font_get_glyph_index(RID p_font_rid, int p_size, char32_t p_char, char32_t p_variation_selector = 0) const override;
+	virtual 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;
 
-	virtual bool font_has_char(RID p_font_rid, char32_t p_char) const override;
-	virtual String font_get_supported_chars(RID p_font_rid) const override;
+	virtual bool font_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;
 
-	virtual void font_render_range(RID p_font, const Vector2i &p_size, char32_t p_start, char32_t p_end) override;
-	virtual void font_render_glyph(RID p_font_rid, const Vector2i &p_size, int32_t p_index) override;
+	virtual 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;
 
-	virtual void font_draw_glyph(RID p_font, RID p_canvas, int p_size, const Vector2 &p_pos, int32_t p_index, const Color &p_color = Color(1, 1, 1)) const override;
-	virtual void font_draw_glyph_outline(RID p_font, RID p_canvas, int p_size, int p_outline_size, const Vector2 &p_pos, int32_t p_index, const Color &p_color = Color(1, 1, 1)) const override;
+	virtual 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;
 
-	virtual bool font_is_language_supported(RID p_font_rid, const String &p_language) const override;
-	virtual void font_set_language_support_override(RID p_font_rid, const String &p_language, bool p_supported) override;
-	virtual bool font_get_language_support_override(RID p_font_rid, const String &p_language) override;
-	virtual void font_remove_language_support_override(RID p_font_rid, const String &p_language) override;
-	virtual Vector<String> font_get_language_support_overrides(RID p_font_rid) override;
+	virtual bool font_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;
 
-	virtual bool font_is_script_supported(RID p_font_rid, const String &p_script) const override;
-	virtual void font_set_script_support_override(RID p_font_rid, const String &p_script, bool p_supported) override;
-	virtual bool font_get_script_support_override(RID p_font_rid, const String &p_script) override;
-	virtual void font_remove_script_support_override(RID p_font_rid, const String &p_script) override;
-	virtual Vector<String> font_get_script_support_overrides(RID p_font_rid) override;
+	virtual 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;
 
-	virtual void font_set_opentype_feature_overrides(RID p_font_rid, const Dictionary &p_overrides) override;
-	virtual Dictionary font_get_opentype_feature_overrides(RID p_font_rid) const override;
+	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;
 
-	virtual Dictionary font_supported_feature_list(RID p_font_rid) const override;
-	virtual Dictionary font_supported_variation_list(RID p_font_rid) const override;
+	virtual 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;
 
-	virtual float font_get_global_oversampling() const override;
-	virtual void font_set_global_oversampling(float p_oversampling) override;
+	virtual double font_get_global_oversampling() const override;
+	virtual void font_set_global_oversampling(double p_oversampling) override;
 
 	/* Shaped text buffer interface */
 
 	virtual RID create_shaped_text(Direction p_direction = DIRECTION_AUTO, Orientation p_orientation = ORIENTATION_HORIZONTAL) override;
 
-	virtual void shaped_text_clear(RID p_shaped) override;
+	virtual void shaped_text_clear(const RID &p_shaped) override;
 
-	virtual void shaped_text_set_direction(RID p_shaped, Direction p_direction = DIRECTION_AUTO) override;
-	virtual Direction shaped_text_get_direction(RID p_shaped) const override;
-	virtual Direction shaped_text_get_inferred_direction(RID p_shaped) const override;
+	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;
 
-	virtual void shaped_text_set_bidi_override(RID p_shaped, const Array &p_override) override;
+	virtual void shaped_text_set_bidi_override(const RID &p_shaped, const Array &p_override) override;
 
-	virtual void shaped_text_set_custom_punctuation(RID p_shaped, const String &p_punct) override;
-	virtual String shaped_text_get_custom_punctuation(RID p_shaped) const override;
+	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;
 
-	virtual void shaped_text_set_orientation(RID p_shaped, Orientation p_orientation = ORIENTATION_HORIZONTAL) override;
-	virtual Orientation shaped_text_get_orientation(RID p_shaped) const override;
+	virtual void shaped_text_set_orientation(const RID &p_shaped, Orientation p_orientation = ORIENTATION_HORIZONTAL) override;
+	virtual Orientation shaped_text_get_orientation(const RID &p_shaped) const override;
 
-	virtual void shaped_text_set_preserve_invalid(RID p_shaped, bool p_enabled) override;
-	virtual bool shaped_text_get_preserve_invalid(RID p_shaped) const override;
+	virtual void shaped_text_set_preserve_invalid(const RID &p_shaped, bool p_enabled) override;
+	virtual bool shaped_text_get_preserve_invalid(const RID &p_shaped) const override;
 
-	virtual void shaped_text_set_preserve_control(RID p_shaped, bool p_enabled) override;
-	virtual bool shaped_text_get_preserve_control(RID p_shaped) const override;
+	virtual 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;
 
-	virtual bool shaped_text_add_string(RID p_shaped, const String &p_text, const Vector<RID> &p_fonts, int p_size, const Dictionary &p_opentype_features = Dictionary(), const String &p_language = "", const Variant &p_meta = Variant()) override;
-	virtual bool shaped_text_add_object(RID p_shaped, Variant p_key, const Size2 &p_size, InlineAlignment p_inline_align = INLINE_ALIGNMENT_CENTER, int p_length = 1) override;
-	virtual bool shaped_text_resize_object(RID p_shaped, Variant p_key, const Size2 &p_size, InlineAlignment p_inline_align = INLINE_ALIGNMENT_CENTER) override;
+	virtual bool shaped_text_add_string(const RID &p_shaped, const String &p_text, const Array &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;
 
-	virtual int shaped_get_span_count(RID p_shaped) const override;
-	virtual Variant shaped_get_span_meta(RID p_shaped, int p_index) const override;
-	virtual void shaped_set_span_update_font(RID p_shaped, int p_index, const Vector<RID> &p_fonts, int p_size, const Dictionary &p_opentype_features = Dictionary()) override;
+	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 Array &p_fonts, int64_t p_size, const Dictionary &p_opentype_features = Dictionary()) override;
 
-	virtual RID shaped_text_substr(RID p_shaped, int p_start, int p_length) const override;
-	virtual RID shaped_text_get_parent(RID p_shaped) const override;
+	virtual 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;
 
-	virtual float shaped_text_fit_to_width(RID p_shaped, float p_width, uint16_t /*JustificationFlag*/ p_jst_flags = JUSTIFICATION_WORD_BOUND | JUSTIFICATION_KASHIDA) override;
-	virtual float shaped_text_tab_align(RID p_shaped, const PackedFloat32Array &p_tab_stops) override;
+	virtual double shaped_text_fit_to_width(const RID &p_shaped, double p_width, int64_t /*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;
 
-	virtual bool shaped_text_shape(RID p_shaped) override;
-	virtual bool shaped_text_update_breaks(RID p_shaped) override;
-	virtual bool shaped_text_update_justification_ops(RID p_shaped) override;
+	virtual bool shaped_text_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;
 
-	virtual int shaped_text_get_trim_pos(RID p_shaped) const override;
-	virtual int shaped_text_get_ellipsis_pos(RID p_shaped) const override;
-	virtual const Glyph *shaped_text_get_ellipsis_glyphs(RID p_shaped) const override;
-	virtual int shaped_text_get_ellipsis_glyph_count(RID p_shaped) const override;
+	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;
 
-	virtual void shaped_text_overrun_trim_to_width(RID p_shaped, float p_width, uint16_t p_trim_flags) override;
+	virtual void shaped_text_overrun_trim_to_width(const RID &p_shaped, double p_width, int64_t p_trim_flags) override;
 
-	virtual bool shaped_text_is_ready(RID p_shaped) const override;
+	virtual bool shaped_text_is_ready(const RID &p_shaped) const override;
 
-	virtual const Glyph *shaped_text_get_glyphs(RID p_shaped) const override;
-	virtual const Glyph *shaped_text_sort_logical(RID p_shaped) override;
-	virtual int shaped_text_get_glyph_count(RID p_shaped) const override;
+	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;
 
-	virtual Vector2i shaped_text_get_range(RID p_shaped) const override;
+	virtual Vector2i shaped_text_get_range(const RID &p_shaped) const override;
 
-	virtual Array shaped_text_get_objects(RID p_shaped) const override;
-	virtual Rect2 shaped_text_get_object_rect(RID p_shaped, Variant p_key) const override;
+	virtual 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;
 
-	virtual Size2 shaped_text_get_size(RID p_shaped) const override;
-	virtual float shaped_text_get_ascent(RID p_shaped) const override;
-	virtual float shaped_text_get_descent(RID p_shaped) const override;
-	virtual float shaped_text_get_width(RID p_shaped) const override;
-	virtual float shaped_text_get_underline_position(RID p_shaped) const override;
-	virtual float shaped_text_get_underline_thickness(RID p_shaped) const override;
+	virtual 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;
 
 	virtual String format_number(const String &p_string, const String &p_language = "") const override;
 	virtual String parse_number(const String &p_string, const String &p_language = "") const override;