godot/modules/text_server_fb/gdextension_build/SConstruct

#!/usr/bin/env python
import atexit
import sys
import time

import methods

# Enable ANSI escape code support on Windows 10 and later (for colored console output).
# <https://github.com/python/cpython/issues/73245>
if sys.stdout.isatty() and sys.platform == "win32":
    try:
        from ctypes import WinError, byref, windll  # type: ignore
        from ctypes.wintypes import DWORD  # type: ignore

        stdout_handle = windll.kernel32.GetStdHandle(DWORD(-11))
        mode = DWORD(0)
        if not windll.kernel32.GetConsoleMode(stdout_handle, byref(mode)):
            raise WinError()
        mode = DWORD(mode.value | 4)
        if not windll.kernel32.SetConsoleMode(stdout_handle, mode):
            raise WinError()
    except Exception as e:
        methods._colorize = False
        methods.print_error(f"Failed to enable ANSI escape code support, disabling color output.\n{e}")

# 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("brotli_enabled", "Use Brotli library", True))
opts.Add(BoolVariable("freetype_enabled", "Use FreeType library", True))
opts.Add(BoolVariable("msdfgen_enabled", "Use MSDFgen library (require FreeType)", True))
opts.Add(BoolVariable("thorvg_enabled", "Use ThorVG library (require FreeType)", True))
opts.Add(BoolVariable("verbose", "Enable verbose output for the compilation", False))

opts.Update(env)

if not env["verbose"]:
    methods.no_verbose(env)

# ThorVG
if env["thorvg_enabled"] and env["freetype_enabled"]:
    env_tvg = env.Clone()
    env_tvg.disable_warnings()

    thirdparty_tvg_dir = "../../../thirdparty/thorvg/"
    thirdparty_tvg_sources = [
        # common
        "src/common/tvgCompressor.cpp",
        "src/common/tvgLines.cpp",
        "src/common/tvgMath.cpp",
        "src/common/tvgStr.cpp",
        # SVG parser
        "src/loaders/svg/tvgSvgCssStyle.cpp",
        "src/loaders/svg/tvgSvgLoader.cpp",
        "src/loaders/svg/tvgSvgPath.cpp",
        "src/loaders/svg/tvgSvgSceneBuilder.cpp",
        "src/loaders/svg/tvgSvgUtil.cpp",
        "src/loaders/svg/tvgXmlParser.cpp",
        "src/loaders/raw/tvgRawLoader.cpp",
        # image loaders
        "src/loaders/external_png/tvgPngLoader.cpp",
        "src/loaders/jpg/tvgJpgd.cpp",
        "src/loaders/jpg/tvgJpgLoader.cpp",
        # renderer common
        "src/renderer/tvgAccessor.cpp",
        # "src/renderer/tvgAnimation.cpp",
        "src/renderer/tvgCanvas.cpp",
        "src/renderer/tvgFill.cpp",
        # "src/renderer/tvgGlCanvas.cpp",
        "src/renderer/tvgInitializer.cpp",
        "src/renderer/tvgLoader.cpp",
        "src/renderer/tvgPaint.cpp",
        "src/renderer/tvgPicture.cpp",
        "src/renderer/tvgRender.cpp",
        # "src/renderer/tvgSaver.cpp",
        "src/renderer/tvgScene.cpp",
        "src/renderer/tvgShape.cpp",
        "src/renderer/tvgSwCanvas.cpp",
        "src/renderer/tvgTaskScheduler.cpp",
        "src/renderer/tvgText.cpp",
        # "src/renderer/tvgWgCanvas.cpp",
        # renderer sw_engine
        "src/renderer/sw_engine/tvgSwFill.cpp",
        "src/renderer/sw_engine/tvgSwImage.cpp",
        "src/renderer/sw_engine/tvgSwMath.cpp",
        "src/renderer/sw_engine/tvgSwMemPool.cpp",
        "src/renderer/sw_engine/tvgSwRaster.cpp",
        "src/renderer/sw_engine/tvgSwRenderer.cpp",
        "src/renderer/sw_engine/tvgSwRle.cpp",
        "src/renderer/sw_engine/tvgSwShape.cpp",
        "src/renderer/sw_engine/tvgSwStroke.cpp",
    ]
    thirdparty_tvg_sources = [thirdparty_tvg_dir + file for file in thirdparty_tvg_sources]

    env_tvg.Append(
        CPPPATH=[
            "../../../thirdparty/thorvg/inc",
            "../../../thirdparty/thorvg/src/common",
            "../../../thirdparty/thorvg/src/renderer",
            "../../../thirdparty/thorvg/src/renderer/sw_engine",
            "../../../thirdparty/thorvg/src/loaders/svg",
            "../../../thirdparty/thorvg/src/loaders/raw",
            "../../../thirdparty/thorvg/src/loaders/external_png",
            "../../../thirdparty/thorvg/src/loaders/jpg",
            "../../../thirdparty/libpng",
        ]
    )

    # Enable ThorVG static object linking.
    env_tvg.Append(CPPDEFINES=["TVG_STATIC"])

    env.Append(
        CPPPATH=[
            "../../../thirdparty/thorvg/inc",
            "../../../thirdparty/thorvg/src/common",
            "../../../thirdparty/thorvg/src/renderer",
        ]
    )
    env.Append(CPPDEFINES=["MODULE_SVG_ENABLED"])

    lib = env_tvg.Library(
        f'tvg_builtin{env["suffix"]}{env["LIBSUFFIX"]}',
        thirdparty_tvg_sources,
    )
    env.Append(LIBS=[lib])

# 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/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(CPPDEFINES=[("MSDFGEN_PUBLIC", "")])
    env_msdfgen.Append(CPPPATH=["../../../thirdparty/freetype/include", "../../../thirdparty/msdfgen"])
    env.Append(CPPPATH=["../../../thirdparty/msdfgen"])
    env.Append(CPPDEFINES=[("MSDFGEN_PUBLIC", "")])
    env.Append(CPPDEFINES=["MODULE_MSDFGEN_ENABLED"])

    lib = env_msdfgen.Library(
        f'msdfgen_builtin{env["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/svg/svg.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",
        "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]

    if env["brotli_enabled"]:
        thirdparty_brotli_dir = "../../../thirdparty/brotli/"
        thirdparty_brotli_sources = [
            "common/constants.c",
            "common/context.c",
            "common/dictionary.c",
            "common/platform.c",
            "common/shared_dictionary.c",
            "common/transform.c",
            "dec/bit_reader.c",
            "dec/decode.c",
            "dec/huffman.c",
            "dec/state.c",
        ]
        thirdparty_freetype_sources += [thirdparty_brotli_dir + file for file in thirdparty_brotli_sources]
        env_freetype.Append(CPPDEFINES=["FT_CONFIG_OPTION_USE_BROTLI"])
        env_freetype.Prepend(CPPPATH=[thirdparty_brotli_dir + "include"])
        env.Append(CPPDEFINES=["FT_CONFIG_OPTION_USE_BROTLI"])

    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",
            "FT_CONFIG_OPTION_SYSTEM_ZLIB",
        ]
    )
    if env.dev_build:
        env_freetype.Append(CPPDEFINES=["ZLIB_DEBUG"])

    env.Append(CPPDEFINES=["MODULE_FREETYPE_ENABLED"])

    lib = env_freetype.Library(
        f'freetype_builtin{env["suffix"]}{env["LIBSUFFIX"]}',
        thirdparty_freetype_sources,
    )
    env.Append(LIBS=[lib])


env.Append(CPPDEFINES=["GDEXTENSION"])
env.Append(CPPPATH=["../"])
sources = Glob("../*.cpp")

if env["platform"] == "macos":
    methods.write_macos_plist(
        f'./bin/libtextserver_fallback.macos.{env["target"]}.framework',
        f'libtextserver_fallback.macos.{env["target"]}',
        "org.godotengine.textserver_fallback",
        "Fallback Text Server",
    )
    library = env.SharedLibrary(
        f'./bin/libtextserver_fallback.macos.{env["target"]}.framework/libtextserver_fallback.macos.{env["target"]}',
        source=sources,
    )
else:
    library = env.SharedLibrary(
        f'./bin/libtextserver_fallback{env["suffix"]}{env["SHLIBSUFFIX"]}',
        source=sources,
    )

Default(library)


def print_elapsed_time():
    elapsed_time_sec = round(time.time() - time_at_start, 2)
    time_centiseconds = round((elapsed_time_sec % 1) * 100)
    print(
        "{}[Time elapsed: {}.{:02}]{}".format(
            methods.ANSI.GRAY,
            time.strftime("%H:%M:%S", time.gmtime(elapsed_time_sec)),
            time_centiseconds,
            methods.ANSI.RESET,
        )
    )


atexit.register(print_elapsed_time)