Added some of the scons files from pandmeonium.

SConstruct

@@ -1,105 +1,809 @@
-#!python
+#!/usr/bin/env python
-import os, subprocess
 
-opts = Variables([], ARGUMENTS)
+EnsureSConsVersion(0, 98, 1)
 
-# Gets the standard flags CC, CCX, etc.
+# System
-env = DefaultEnvironment()
+import atexit
+import glob
+import os
+import pickle
+import sys
+import time
+from collections import OrderedDict
 
-# Define our options
+# Local
-opts.Add(EnumVariable('target', "Compilation target", 'debug', ['d', 'debug', 'r', 'release']))
+import methods
-opts.Add(EnumVariable('platform', "Compilation platform", '', ['', 'windows', 'x11', 'linux', 'osx']))
+import gles_builders
-opts.Add(EnumVariable('p', "Compilation target, alias for 'platform'", '', ['', 'windows', 'x11', 'linux', 'osx']))
+import scu_builders
-opts.Add(BoolVariable('use_llvm', "Use the LLVM / Clang compiler", 'no'))
+from platform_methods import run_in_subprocess
-opts.Add(PathVariable('target_path', 'The path where the lib is installed.', '../game/gdn/'))
-opts.Add(PathVariable('target_name', 'The library name.', 'libgdexample', PathVariable.PathAccept))
 
-# Local dependency paths, adapt them to your setup
+# scan possible build platforms
-godot_headers_path = "gdnative_cpp/pandemonium_headers/"
-cpp_bindings_path = "gdnative_cpp/"
-cpp_library = "libpandemonium-cpp"
 
-# only support 64 at this time..
+platform_list = []  # list of platforms
-bits = 64
+platform_opts = {}  # options for each platform
+platform_flags = {}  # flags for each platform
 
-# Updates the environment with the option variables.
+active_platforms = []
-opts.Update(env)
+active_platform_ids = []
+platform_exporters = []
+platform_apis = []
 
-# Process some arguments
+time_at_start = time.time()
-if env['use_llvm']:
-    env['CC'] = 'clang'
-    env['CXX'] = 'clang++'
 
-if env['p'] != '':
+for x in sorted(glob.glob("platform/*")):
-    env['platform'] = env['p']
+    if not os.path.isdir(x) or not os.path.exists(x + "/detect.py"):
+        continue
+    tmppath = "./" + x
 
-if env['platform'] == '':
+    sys.path.insert(0, tmppath)
-    print("No valid target platform selected.")
+    import detect
-    quit();
 
-# Check our platform specifics
+    if os.path.exists(x + "/export/export.cpp"):
-if env['platform'] == "osx":
+        platform_exporters.append(x[9:])
-    env['target_path'] += 'osx/'
+    if os.path.exists(x + "/api/api.cpp"):
-    cpp_library += '.osx'
+        platform_apis.append(x[9:])
-    if env['target'] in ('debug', 'd'):
+    if detect.is_active():
-        env.Append(CCFLAGS = ['-g','-O2', '-arch', 'x86_64', '-std=c++17'])
+        active_platforms.append(detect.get_name())
-        env.Append(LINKFLAGS = ['-arch', 'x86_64'])
+        active_platform_ids.append(x)
-    else:
+    if detect.can_build():
-        env.Append(CCFLAGS = ['-g','-O3', '-arch', 'x86_64', '-std=c++17'])
+        x = x.replace("platform/", "")  # rest of world
-        env.Append(LINKFLAGS = ['-arch', 'x86_64'])
+        x = x.replace("platform\\", "")  # win32
+        platform_list += [x]
+        platform_opts[x] = detect.get_opts()
+        platform_flags[x] = detect.get_flags()
+    sys.path.remove(tmppath)
+    sys.modules.pop("detect")
 
-elif env['platform'] in ('x11', 'linux'):
+methods.save_active_platforms(active_platforms, active_platform_ids)
-    env['target_path'] += 'x11/'
-    cpp_library += '.linux'
-    if env['target'] in ('debug', 'd'):
-        env.Append(CCFLAGS = ['-fPIC', '-g3','-Og', '-std=c++17'])
-    else:
-        env.Append(CCFLAGS = ['-fPIC', '-g','-O3', '-std=c++17'])
 
-elif env['platform'] == "windows":
+custom_tools = ["default"]
-    env['target_path'] += 'win64/'
-    cpp_library += '.windows'
-    # This makes sure to keep the session environment variables on windows,
-    # that way you can run scons in a vs 2017 prompt and it will find all the required tools
-    env.Append(ENV = os.environ)
 
-    env.Append(CCFLAGS = ['-DWIN32', '-D_WIN32', '-D_WINDOWS', '-W3', '-GR', '-D_CRT_SECURE_NO_WARNINGS'])
+platform_arg = ARGUMENTS.get("platform", ARGUMENTS.get("p", False))
-    if env['target'] in ('debug', 'd'):
-        env.Append(CCFLAGS = ['-EHsc', '-D_DEBUG', '-MDd'])
-    else:
-        env.Append(CCFLAGS = ['-O2', '-EHsc', '-DNDEBUG', '-MD'])
 
-if env['target'] in ('debug', 'd'):
+if platform_arg == "android":
-    cpp_library += '.debug'
+    custom_tools = ["clang", "clang++", "as", "ar", "link"]
+elif platform_arg == "javascript":
+    # Use generic POSIX build toolchain for Emscripten.
+    custom_tools = ["cc", "c++", "ar", "link", "textfile", "zip"]
+elif os.name == "nt" and methods.get_cmdline_bool("use_mingw", False):
+    custom_tools = ["mingw"]
+
+# We let SCons build its default ENV as it includes OS-specific things which we don't
+# want to have to pull in manually.
+# Then we prepend PATH to make it take precedence, while preserving SCons' own entries.
+env_base = Environment(tools=custom_tools)
+env_base.PrependENVPath("PATH", os.getenv("PATH"))
+env_base.PrependENVPath("PKG_CONFIG_PATH", os.getenv("PKG_CONFIG_PATH"))
+if "TERM" in os.environ:  # Used for colored output.
+    env_base["ENV"]["TERM"] = os.environ["TERM"]
+
+env_base.disabled_modules = []
+env_base.use_ptrcall = False
+env_base.module_version_string = ""
+env_base.msvc = False
+
+env_base.__class__.disable_module = methods.disable_module
+
+env_base.__class__.add_module_version_string = methods.add_module_version_string
+
+env_base.__class__.add_source_files = methods.add_source_files
+env_base.__class__.use_windows_spawn_fix = methods.use_windows_spawn_fix
+env_base.__class__.split_lib = methods.split_lib
+
+env_base.__class__.add_shared_library = methods.add_shared_library
+env_base.__class__.add_library = methods.add_library
+env_base.__class__.add_program = methods.add_program
+env_base.__class__.CommandNoCache = methods.CommandNoCache
+env_base.__class__.disable_warnings = methods.disable_warnings
+env_base.__class__.force_optimization_on_debug = methods.force_optimization_on_debug
+env_base.__class__.module_add_dependencies = methods.module_add_dependencies
+env_base.__class__.module_check_dependencies = methods.module_check_dependencies
+
+env_base["x86_libtheora_opt_gcc"] = False
+env_base["x86_libtheora_opt_vc"] = False
+
+# avoid issues when building with different versions of python out of the same directory
+env_base.SConsignFile(".sconsign{0}.dblite".format(pickle.HIGHEST_PROTOCOL))
+
+# Build options
+
+customs = ["custom.py"]
+
+profile = ARGUMENTS.get("profile", "")
+if profile:
+    if os.path.isfile(profile):
+        customs.append(profile)
+    elif os.path.isfile(profile + ".py"):
+        customs.append(profile + ".py")
+
+opts = Variables(customs, ARGUMENTS)
+
+# Target build options
+opts.Add("p", "Platform (alias for 'platform')", "")
+opts.Add("platform", "Target platform (%s)" % ("|".join(platform_list),), "")
+opts.Add(BoolVariable("tools", "Build the tools (a.k.a. the Pandemonium editor)", True))
+opts.Add(EnumVariable("target", "Compilation target", "debug", ("debug", "release_debug", "release")))
+opts.Add("arch", "Platform-dependent architecture (arm/arm64/x86/x64/mips/...)", "")
+opts.Add(EnumVariable("bits", "Target platform bits", "default", ("default", "32", "64")))
+opts.Add(EnumVariable("optimize", "Optimization type", "speed", ("speed", "size", "none")))
+opts.Add(BoolVariable("production", "Set defaults to build Pandemonium for use in production", False))
+opts.Add(EnumVariable("lto", "Link-time optimization (production builds)", "none", ("none", "auto", "thin", "full")))
+opts.Add(BoolVariable("use_rtti", "Use RTTI", False))
+
+# Components
+opts.Add(BoolVariable("deprecated", "Enable deprecated features", True))
+opts.Add(BoolVariable("minizip", "Enable ZIP archive support using minizip", True))
+opts.Add(BoolVariable("xaudio2", "Enable the XAudio2 audio driver", False))
+opts.Add(BoolVariable("disable_exceptions", "Force disabling exception handling code", True))
+opts.Add("custom_modules", "A list of comma-separated directory paths containing custom modules to build.", "")
+opts.Add(BoolVariable("custom_modules_recursive", "Detect custom modules recursively for each specified path.", True))
+
+# Advanced options
+opts.Add(BoolVariable("dev", "If yes, alias for verbose=yes warnings=extra werror=yes", False))
+opts.Add(BoolVariable("fast_unsafe", "Enable unsafe options for faster rebuilds", False))
+opts.Add(BoolVariable("compiledb", "Generate compilation DB (`compile_commands.json`) for external tools", False))
+opts.Add(BoolVariable("verbose", "Enable verbose output for the compilation", False))
+opts.Add(BoolVariable("progress", "Show a progress indicator during compilation", True))
+opts.Add(EnumVariable("warnings", "Level of compilation warnings", "all", ("extra", "all", "moderate", "no")))
+opts.Add(BoolVariable("werror", "Treat compiler warnings as errors", False))
+opts.Add("extra_suffix", "Custom extra suffix added to the base filename of all generated binary files", "")
+opts.Add(BoolVariable("vsproj", "Generate a Visual Studio solution", False))
+opts.Add(
+    BoolVariable(
+        "split_libmodules",
+        "Split intermediate libmodules.a in smaller chunks to prevent exceeding linker command line size (forced to True when using MinGW)",
+        False,
+    )
+)
+opts.Add(BoolVariable("disable_3d", "Disable 3D nodes for a smaller executable", False))
+opts.Add(BoolVariable("disable_advanced_gui", "Disable advanced GUI nodes and behaviors", False))
+opts.Add(BoolVariable("no_editor_splash", "Don't use the custom splash screen for the editor", True))
+opts.Add("system_certs_path", "Use this path as SSL certificates default for editor (for package maintainers)", "")
+opts.Add(BoolVariable("use_precise_math_checks", "Math checks use very precise epsilon (debug option)", False))
+opts.Add(BoolVariable("scu_build", "Use single compilation unit build", False))
+opts.Add(
+    EnumVariable(
+        "rids",
+        "Server object management technique (debug option)",
+        "pointers",
+        ("pointers", "handles", "tracked_handles"),
+    )
+)
+opts.Add(BoolVariable("editor_docs", "Whether to add docs to an editor build or not. Disabling this can significantly reduce incremental compile times. Only relevant for editor builds!", True))
+
+# Thirdparty libraries
+opts.Add(BoolVariable("builtin_certs", "Use the built-in SSL certificates bundles", True))
+opts.Add(BoolVariable("builtin_enet", "Use the built-in ENet library", True))
+opts.Add(BoolVariable("builtin_freetype", "Use the built-in FreeType library", True))
+opts.Add(BoolVariable("builtin_libogg", "Use the built-in libogg library", True))
+opts.Add(BoolVariable("builtin_libpng", "Use the built-in libpng library", True))
+opts.Add(BoolVariable("builtin_libtheora", "Use the built-in libtheora library", True))
+opts.Add(BoolVariable("builtin_libvorbis", "Use the built-in libvorbis library", True))
+opts.Add(BoolVariable("builtin_wslay", "Use the built-in wslay library", True))
+opts.Add(BoolVariable("builtin_mbedtls", "Use the built-in mbedTLS library", True))
+opts.Add(BoolVariable("builtin_miniupnpc", "Use the built-in miniupnpc library", True))
+opts.Add(BoolVariable("builtin_opus", "Use the built-in Opus library", True))
+opts.Add(BoolVariable("builtin_pcre2", "Use the built-in PCRE2 library", True))
+opts.Add(BoolVariable("builtin_pcre2_with_jit", "Use JIT compiler for the built-in PCRE2 library", True))
+opts.Add(BoolVariable("builtin_recast", "Use the built-in Recast library", True))
+opts.Add(BoolVariable("builtin_rvo2_2d", "Use the built-in RVO2 2D library", True))
+opts.Add(BoolVariable("builtin_rvo2_3d", "Use the built-in RVO2 3D library", True))
+opts.Add(BoolVariable("builtin_squish", "Use the built-in squish library", True))
+opts.Add(BoolVariable("builtin_zlib", "Use the built-in zlib library", True))
+opts.Add(BoolVariable("builtin_zstd", "Use the built-in Zstd library", True))
+
+# Compilation environment setup
+opts.Add("CXX", "C++ compiler")
+opts.Add("CC", "C compiler")
+opts.Add("LINK", "Linker")
+opts.Add("CCFLAGS", "Custom flags for both the C and C++ compilers")
+opts.Add("CFLAGS", "Custom flags for the C compiler")
+opts.Add("CXXFLAGS", "Custom flags for the C++ compiler")
+opts.Add("LINKFLAGS", "Custom flags for the linker")
+
+# Update the environment to have all above options defined
+# in following code (especially platform and custom_modules).
+opts.Update(env_base)
+
+# Platform selection: validate input, and add options.
+
+selected_platform = ""
+
+if env_base["platform"] != "":
+    selected_platform = env_base["platform"]
+elif env_base["p"] != "":
+    selected_platform = env_base["p"]
 else:
-    cpp_library += '.release'
+    # Missing `platform` argument, try to detect platform automatically
+    if (
+        sys.platform.startswith("linux")
+        or sys.platform.startswith("dragonfly")
+        or sys.platform.startswith("freebsd")
+        or sys.platform.startswith("netbsd")
+        or sys.platform.startswith("openbsd")
+    ):
+        selected_platform = "x11"
+    elif sys.platform == "darwin":
+        selected_platform = "osx"
+    elif sys.platform == "win32":
+        selected_platform = "windows"
+    else:
+        print("Could not detect platform automatically. Supported platforms:")
+        for x in platform_list:
+            print("\t" + x)
+        print("\nPlease run SCons again and select a valid platform: platform=<string>")
 
-cpp_library += '.' + str(bits)
+    if selected_platform != "":
+        print("Automatically detected platform: " + selected_platform)
 
-# make sure our binding library is properly includes
+if selected_platform == "macos":
-env.Append(CPPPATH=['.', godot_headers_path, cpp_bindings_path, cpp_bindings_path + '/core/', cpp_bindings_path + '/gen/'])
+    # Alias for forward compatibility.
-env.Append(LIBPATH=[cpp_bindings_path + 'bin/'])
+    print('Platform "macos" is still called "osx" in Godot 3.x. Building for platform "osx".')
-env.Append(LIBS=[cpp_library])
+    selected_platform = "osx"
 
-env.Append(CCFLAGS = ['-DGDNATIVE'])
+if selected_platform == "ios":
+    # Alias for forward compatibility.
+    print('Platform "ios" is still called "iphone" in Godot 3.x. Building for platform "iphone".')
+    selected_platform = "iphone"
 
-# tweak this if you want to use different folders, or more folders, to store your source code in.
+if selected_platform in ["linux", "bsd", "linuxbsd"]:
-#env.Append(CPPPATH=['src/'])
+    if selected_platform == "linuxbsd":
-#sources = Glob('src/*.cpp')
+        # Alias for forward compatibility.
+        print('Platform "linuxbsd" is still called "x11" in Pandemonium 3.x. Building for platform "x11".')
+    # Alias for convenience.
+    selected_platform = "x11"
 
-sources = [
+# Make sure to update this to the found, valid platform as it's used through the buildsystem as the reference.
-    "gdlibrary.cpp",
+# It should always be re-set after calling `opts.Update()` otherwise it uses the original input value.
+env_base["platform"] = selected_platform
 
-    "mlpp/lin_alg/mlpp_vector.cpp",
+# Add platform-specific options.
-    "mlpp/lin_alg/mlpp_matrix.cpp",
+if selected_platform in platform_opts:
-    "mlpp/lin_alg/mlpp_tensor3.cpp",
+    for opt in platform_opts[selected_platform]:
-    "mlpp/lin_alg/lin_alg.cpp",
+        opts.Add(opt)
 
-]
+# Update the environment to take platform-specific options into account.
+opts.Update(env_base)
+env_base["platform"] = selected_platform  # Must always be re-set after calling opts.Update().
 
-library = env.SharedLibrary(target=env['target_path'] + env['target_name'] , source=sources)
+# Detect modules.
+modules_detected = OrderedDict()
+module_search_paths = [ "modules", methods.convert_custom_modules_path("editor_modules") ]  # Built-in path.
 
-Default(library)
+# maybe?
+#if env_base["tools"]:
+#    module_search_paths.append(methods.convert_custom_modules_path("editor_modules"))
 
-# Generates help for the -h scons option.
+if env_base["custom_modules"]:
-Help(opts.GenerateHelpText(env))
+    paths = env_base["custom_modules"].split(",")
+    for p in paths:
+        try:
+            module_search_paths.append(methods.convert_custom_modules_path(p))
+        except ValueError as e:
+            print(e)
+            sys.exit(255)
+
+for path in module_search_paths:
+    if path == "modules":
+        # Built-in modules don't have nested modules,
+        # so save the time it takes to parse directories.
+        modules = methods.detect_modules(path, recursive=False)
+    else:  # Custom.
+        modules = methods.detect_modules(path, env_base["custom_modules_recursive"])
+        # Provide default include path for both the custom module search `path`
+        # and the base directory containing custom modules, as it may be different
+        # from the built-in "modules" name (e.g. "custom_modules/summator/summator.h"),
+        # so it can be referenced simply as `#include "summator/summator.h"`
+        # independently of where a module is located on user's filesystem.
+        env_base.Prepend(CPPPATH=[path, os.path.dirname(path)])
+    # Note: custom modules can override built-in ones.
+    modules_detected.update(modules)
+
+# Add module options
+for name, path in modules_detected.items():
+    enabled = True
+    sys.path.insert(0, path)
+    import config
+
+    try:
+        enabled = config.is_enabled()
+    except AttributeError:
+        pass
+    sys.path.remove(path)
+    sys.modules.pop("config")
+    opts.Add(BoolVariable("module_" + name + "_enabled", "Enable module '%s'" % (name,), enabled))
+
+methods.write_modules(modules_detected)
+
+# Update the environment again after all the module options are added.
+opts.Update(env_base)
+env_base["platform"] = selected_platform  # Must always be re-set after calling opts.Update().
+Help(opts.GenerateHelpText(env_base))
+
+# add default include paths
+
+env_base.Prepend(CPPPATH=["#"])
+
+# configure ENV for platform
+env_base.platform_exporters = platform_exporters
+env_base.platform_apis = platform_apis
+
+# Build type defines - more platform-specific ones can be in detect.py.
+if env_base["target"] == "release_debug" or env_base["target"] == "debug":
+    # DEBUG_ENABLED enables debugging *features* and debug-only code, which is intended
+    # to give *users* extra debugging information for their game development.
+    env_base.Append(CPPDEFINES=["DEBUG_ENABLED"])
+
+if env_base["target"] == "debug":
+    # DEV_ENABLED enables *engine developer* code which should only be compiled for those
+    # working on the engine itself.
+    env_base.Append(CPPDEFINES=["DEV_ENABLED"])
+else:
+    # Disable assert() for production targets (only used in thirdparty code).
+    env_base.Append(CPPDEFINES=["NDEBUG"])
+
+# SCons speed optimization controlled by the `fast_unsafe` option, which provide
+# more than 10 s speed up for incremental rebuilds.
+# Unsafe as they reduce the certainty of rebuilding all changed files, so it's
+# enabled by default for `debug` builds, and can be overridden from command line.
+# Ref: https://github.com/SCons/scons/wiki/GoFastButton
+if methods.get_cmdline_bool("fast_unsafe", env_base["target"] == "debug"):
+    # Renamed to `content-timestamp` in SCons >= 4.2, keeping MD5 for compat.
+    env_base.Decider("MD5-timestamp")
+    env_base.SetOption("implicit_cache", 1)
+    env_base.SetOption("max_drift", 60)
+
+if env_base["use_precise_math_checks"]:
+    env_base.Append(CPPDEFINES=["PRECISE_MATH_CHECKS"])
+
+if not env_base.File("#main/splash_editor.png").exists():
+    # Force disabling editor splash if missing.
+    env_base["no_editor_splash"] = True
+if env_base["no_editor_splash"]:
+    env_base.Append(CPPDEFINES=["NO_EDITOR_SPLASH"])
+
+if not env_base["deprecated"]:
+    env_base.Append(CPPDEFINES=["DISABLE_DEPRECATED"])
+
+if env_base["rids"] == "handles":
+    env_base.Append(CPPDEFINES=["RID_HANDLES_ENABLED"])
+    print("WARNING: Building with RIDs as handles.")
+
+if env_base["rids"] == "tracked_handles":
+    env_base.Append(CPPDEFINES=["RID_HANDLES_ENABLED"])
+    env_base.Append(CPPDEFINES=["RID_HANDLE_ALLOCATION_TRACKING_ENABLED"])
+    print("WARNING: Building with RIDs as tracked handles.")
+
+if selected_platform in platform_list:
+    tmppath = "./platform/" + selected_platform
+    sys.path.insert(0, tmppath)
+    import detect
+
+    env = env_base.Clone()
+
+    env.extra_suffix = ""
+
+    if env["extra_suffix"] != "":
+        env.extra_suffix += "." + env["extra_suffix"]
+
+    # Environment flags
+    CCFLAGS = env.get("CCFLAGS", "")
+    env["CCFLAGS"] = ""
+    env.Append(CCFLAGS=str(CCFLAGS).split())
+
+    CFLAGS = env.get("CFLAGS", "")
+    env["CFLAGS"] = ""
+    env.Append(CFLAGS=str(CFLAGS).split())
+
+    CXXFLAGS = env.get("CXXFLAGS", "")
+    env["CXXFLAGS"] = ""
+    env.Append(CXXFLAGS=str(CXXFLAGS).split())
+
+    LINKFLAGS = env.get("LINKFLAGS", "")
+    env["LINKFLAGS"] = ""
+    env.Append(LINKFLAGS=str(LINKFLAGS).split())
+
+    # Platform specific flags.
+    # These can sometimes override default options.
+    flag_list = platform_flags[selected_platform]
+    for f in flag_list:
+        if not (f[0] in ARGUMENTS):  # allow command line to override platform flags
+            env[f[0]] = f[1]
+
+    # 'dev' and 'production' are aliases to set default options if they haven't been
+    # set manually by the user.
+    # These need to be checked *after* platform specific flags so that different
+    # default values can be set (e.g. to keep LTO off for `production` on some platforms).
+    if env["dev"]:
+        env["verbose"] = methods.get_cmdline_bool("verbose", True)
+        env["warnings"] = ARGUMENTS.get("warnings", "extra")
+        env["werror"] = methods.get_cmdline_bool("werror", True)
+    if env["production"]:
+        env["use_static_cpp"] = methods.get_cmdline_bool("use_static_cpp", True)
+        env["debug_symbols"] = methods.get_cmdline_bool("debug_symbols", False)
+        # LTO "auto" means we handle the preferred option in each platform detect.py.
+        env["lto"] = ARGUMENTS.get("lto", "auto")
+        if not env["tools"] and env["target"] == "debug":
+            print(
+                "WARNING: Requested `production` build with `tools=no target=debug`, "
+                "this will give you a full debug template (use `target=release_debug` "
+                "for an optimized template with debug features)."
+            )
+
+    # Run SCU file generation script if in a SCU build.
+    if env["scu_build"]:
+        methods.set_scu_folders(scu_builders.generate_scu_files(env["verbose"], env_base["target"] != "debug"))
+
+    # Must happen after the flags' definition, as configure is when most flags
+    # are actually handled to change compile options, etc.
+    detect.configure(env)
+
+    # Needs to happen after configure to handle "auto".
+    if env["lto"] != "none":
+        print("Using LTO: " + env["lto"])
+
+    # Set our C and C++ standard requirements.
+    # Prepending to make it possible to override
+    # This needs to come after `configure`, otherwise we don't have env.msvc.
+    if not env.msvc:
+        # Specifying GNU extensions support explicitly, which are supported by
+        # both GCC and Clang. This mirrors GCC and Clang's current default
+        # compile flags if no -std is specified.
+        env.Prepend(CFLAGS=["-std=gnu11"])
+        env.Prepend(CXXFLAGS=["-std=gnu++14"])
+    else:
+        # MSVC doesn't have clear C standard support, /std only covers C++.
+        # We apply it to CCFLAGS (both C and C++ code) in case it impacts C features.
+        env.Prepend(CCFLAGS=["/std:c++14"])
+
+    if env_base["use_rtti"]:
+        if not env.msvc:
+            env_base.Prepend(CXXFLAGS=["-frtti"])
+            env.Prepend(CXXFLAGS=["-frtti"])
+        else:
+            env_base.Prepend(CXXFLAGS=["/GR"])
+            env.Prepend(CXXFLAGS=["/GR"])
+    else:
+        if not env.msvc:
+            env_base.Prepend(CXXFLAGS=["-fno-rtti"])
+            env.Prepend(CXXFLAGS=["-fno-rtti"])
+        else:
+            env_base.Prepend(CXXFLAGS=["/GR-"])
+            env.Prepend(CXXFLAGS=["/GR-"])
+        
+        # Don't use dynamic_cast, necessary with no-rtti.
+        env_base.Prepend(CPPDEFINES=["NO_SAFE_CAST"])
+        env.Prepend(CPPDEFINES=["NO_SAFE_CAST"])
+
+    # Handle renamed options.
+    if "use_lto" in ARGUMENTS or "use_thinlto" in ARGUMENTS:
+        print("Error: The `use_lto` and `use_thinlto` boolean options have been unified to `lto=<none|thin|full>`.")
+        print("       Please adjust your scripts accordingly.")
+        Exit(255)
+    if "use_lld" in ARGUMENTS:
+        print("Error: The `use_lld` boolean option has been replaced by `linker=<default|bfd|gold|lld|mold>`.")
+        print("       Please adjust your scripts accordingly.")
+        Exit(255)
+
+    # Disable exception handling. Godot doesn't use exceptions anywhere, and this
+    # saves around 20% of binary size and very significant build time (GH-80513).
+    if env["disable_exceptions"]:
+        if env.msvc:
+            env.Append(CPPDEFINES=[("_HAS_EXCEPTIONS", 0)])
+        else:
+            env.Append(CCFLAGS=["-fno-exceptions"])
+    elif env.msvc:
+        env.Append(CCFLAGS=["/EHsc"])
+
+    # Configure compiler warnings
+    if env.msvc:  # MSVC
+        # Truncations, narrowing conversions, signed/unsigned comparisons...
+        disable_nonessential_warnings = ["/wd4267", "/wd4244", "/wd4305", "/wd4018", "/wd4800"]
+        if env["warnings"] == "extra":
+            env.Append(CCFLAGS=["/Wall"])  # Implies /W4
+        elif env["warnings"] == "all":
+            env.Append(CCFLAGS=["/W3"] + disable_nonessential_warnings)
+        elif env["warnings"] == "moderate":
+            env.Append(CCFLAGS=["/W2"] + disable_nonessential_warnings)
+        else:  # 'no'
+            env.Append(CCFLAGS=["/w"])
+
+        if env["werror"]:
+            env.Append(CCFLAGS=["/WX"])
+            env.Append(LINKFLAGS=["/WX"])
+    else:  # GCC, Clang
+        version = methods.get_compiler_version(env) or [-1, -1]
+
+        common_warnings = []
+
+        if methods.using_gcc(env):
+            common_warnings += ["-Wno-misleading-indentation"]
+            if version[0] >= 7:
+                common_warnings += ["-Wshadow-local"]
+        elif methods.using_clang(env) or methods.using_emcc(env):
+            # We often implement `operator<` for structs of pointers as a requirement
+            # for putting them in `Set` or `Map`. We don't mind about unreliable ordering.
+            common_warnings += ["-Wno-ordered-compare-function-pointers"]
+
+        if env["warnings"] == "extra":
+            # Note: enable -Wimplicit-fallthrough for Clang (already part of -Wextra for GCC)
+            # once we switch to C++11 or later (necessary for our FALLTHROUGH macro).
+            env.Append(CCFLAGS=["-Wall", "-Wextra", "-Wwrite-strings", "-Wno-unused-parameter"] + common_warnings)
+            env.Append(CXXFLAGS=["-Wctor-dtor-privacy", "-Wnon-virtual-dtor"])
+            if methods.using_gcc(env):
+                env.Append(
+                    CCFLAGS=[
+                        "-Walloc-zero",
+                        "-Wduplicated-branches",
+                        "-Wduplicated-cond",
+                        "-Wstringop-overflow=4",
+                        "-Wlogical-op",
+                    ]
+                )
+                env.Append(CXXFLAGS=["-Wnoexcept", "-Wplacement-new=1"])
+                if version[0] >= 9:
+                    env.Append(CCFLAGS=["-Wattribute-alias=2"])
+        elif env["warnings"] == "all":
+            env.Append(CCFLAGS=["-Wall"] + common_warnings)
+        elif env["warnings"] == "moderate":
+            env.Append(CCFLAGS=["-Wall", "-Wno-unused"] + common_warnings)
+        else:  # 'no'
+            env.Append(CCFLAGS=["-w"])
+
+        if env["werror"]:
+            env.Append(CCFLAGS=["-Werror"])
+            if methods.using_gcc(env) and version[0] >= 12:  # False positives in our error macros, see GH-58747.
+                env.Append(CCFLAGS=["-Wno-error=return-type"])
+
+    if hasattr(detect, "get_program_suffix"):
+        suffix = "." + detect.get_program_suffix()
+    else:
+        suffix = "." + selected_platform
+
+    if env["target"] == "release":
+        if env["tools"]:
+            print("ERROR: The editor can only be built with `target=debug` or `target=release_debug`.")
+            print("       Use `tools=no target=release` to build a release export template.")
+            Exit(255)
+        suffix += ".opt"
+    elif env["target"] == "release_debug":
+        if env["tools"]:
+            suffix += ".opt.tools"
+        else:
+            suffix += ".opt.debug"
+    else:
+        if env["tools"]:
+            print(
+                "Note: Building a debug binary (which will run slowly). Use `target=release_debug` to build an optimized release binary."
+            )
+            suffix += ".tools"
+        else:
+            print(
+                "Note: Building a debug binary (which will run slowly). Use `target=release` to build an optimized release binary."
+            )
+            suffix += ".debug"
+
+    if env["arch"] != "":
+        suffix += "." + env["arch"]
+    elif env["bits"] == "32":
+        suffix += ".32"
+    elif env["bits"] == "64":
+        suffix += ".64"
+
+    suffix += env.extra_suffix
+
+    sys.path.remove(tmppath)
+    sys.modules.pop("detect")
+
+    modules_enabled = OrderedDict()
+    env.module_dependencies = {}
+    env.module_icons_paths = []
+    env.module_license_files = []
+    env.doc_class_path = {}
+
+    for name, path in modules_detected.items():
+        if not env["module_" + name + "_enabled"]:
+            continue
+
+        sys.path.insert(0, path)
+        env.current_module = name
+        import config
+
+        if config.can_build(env, selected_platform):
+            # Disable it if a required dependency is missing.
+            if not env.module_check_dependencies(name):
+                continue
+
+            config.configure(env)
+
+            # Get doc classes paths (if present)
+            try:
+                doc_classes = config.get_doc_classes()
+                doc_path = config.get_doc_path()
+                for c in doc_classes:
+                    env.doc_class_path[c] = path + "/" + doc_path
+            except Exception:
+                pass
+
+            # Get icon paths (if present)
+            try:
+                icons_path = config.get_icons_path()
+                env.module_icons_paths.append(path + "/" + icons_path)
+            except Exception:
+                # Default path for module icons
+                env.module_icons_paths.append(path + "/" + "icons")
+
+            # Get license path (if present)
+            try:
+                license_file = config.get_license_file()
+
+                if not os.path.isabs(path):
+                    env.module_license_files.append("#" + path + "/" + license_file)
+                else:
+                     env.module_license_files.append(path + "/" + license_file)
+                     
+            except Exception:
+                pass
+
+            modules_enabled[name] = path
+        else:
+            env["module_" + name + "_enabled"] = False
+
+        sys.path.remove(path)
+        sys.modules.pop("config")
+
+    #TODO hack, the editor should be a module as well
+    if env["tools"] and not env["module_freetype_enabled"]:
+        print("The editor (tools=yes) can't be built if freetype is disabled! Stopping.")
+        sys.exit(255)
+
+    env.module_list = modules_enabled
+    methods.sort_module_list(env)
+
+    methods.generate_version_header(env.module_version_string)
+
+    env["PROGSUFFIX"] = suffix + env.module_version_string + env["PROGSUFFIX"]
+    env["OBJSUFFIX"] = suffix + env["OBJSUFFIX"]
+    # (SH)LIBSUFFIX will be used for our own built libraries
+    # LIBSUFFIXES contains LIBSUFFIX and SHLIBSUFFIX by default,
+    # so we need to append the default suffixes to keep the ability
+    # to link against thirdparty libraries (.a, .so, .lib, etc.).
+    if os.name == "nt":
+        # On Windows, only static libraries and import libraries can be
+        # statically linked - both using .lib extension
+        env["LIBSUFFIXES"] += [env["LIBSUFFIX"]]
+    else:
+        env["LIBSUFFIXES"] += [env["LIBSUFFIX"], env["SHLIBSUFFIX"]]
+    env["LIBSUFFIX"] = suffix + env["LIBSUFFIX"]
+    env["SHLIBSUFFIX"] = suffix + env["SHLIBSUFFIX"]
+
+    if env.use_ptrcall:
+        env.Append(CPPDEFINES=["PTRCALL_ENABLED"])
+    if env["tools"]:
+        env.Append(CPPDEFINES=["TOOLS_ENABLED"])
+
+    if env["disable_3d"]:
+        if env["tools"]:
+            print(
+                "Build option 'disable_3d=yes' cannot be used with 'tools=yes' (editor), "
+                "only with 'tools=no' (export template)."
+            )
+            sys.exit(255)
+        else:
+            env.Append(CPPDEFINES=["_3D_DISABLED"])
+
+    if env["disable_advanced_gui"]:
+        if env["tools"]:
+            print(
+                "Build option 'disable_advanced_gui=yes' cannot be used with 'tools=yes' (editor), "
+                "only with 'tools=no' (export template)."
+            )
+            sys.exit(255)
+        else:
+            env.Append(CPPDEFINES=["ADVANCED_GUI_DISABLED"])
+    if env["minizip"]:
+        env.Append(CPPDEFINES=["MINIZIP_ENABLED"])
+
+    if not env["verbose"]:
+        methods.no_verbose(sys, env)
+
+    if not env["platform"] == "server":
+        env.Append(
+            BUILDERS={
+                "GLES2_GLSL": env.Builder(
+                    action=run_in_subprocess(gles_builders.build_gles2_headers), suffix="glsl.gen.h", src_suffix=".glsl"
+                )
+            }
+        )
+
+    scons_cache_path = os.environ.get("SCONS_CACHE")
+    if scons_cache_path != None:
+        CacheDir(scons_cache_path)
+        print("Scons cache enabled... (path: '" + scons_cache_path + "')")
+
+    if env["vsproj"]:
+        env.vs_incs = []
+        env.vs_srcs = []
+
+    if env["compiledb"]:
+        # Generating the compilation DB (`compile_commands.json`) requires SCons 4.0.0 or later.
+        from SCons import __version__ as scons_raw_version
+
+        scons_ver = env._get_major_minor_revision(scons_raw_version)
+
+        if scons_ver < (4, 0, 0):
+            print("The `compiledb=yes` option requires SCons 4.0 or later, but your version is %s." % scons_raw_version)
+            Exit(255)
+
+        env.Tool("compilation_db")
+        env.Alias("compiledb", env.CompilationDatabase())
+
+    Export("env")
+
+    # build subdirs, the build order is dependent on link order.
+
+    SConscript("core/SCsub")
+    SConscript("servers/SCsub")
+    SConscript("scene/SCsub")
+
+    if env["tools"]:
+        SConscript("editor/SCsub")
+
+    SConscript("drivers/SCsub")
+
+    SConscript("platform/SCsub")
+    SConscript("modules/SCsub")
+    SConscript("main/SCsub")
+
+    SConscript("platform/" + selected_platform + "/SCsub")  # build selected platform
+
+    # Microsoft Visual Studio Project Generation
+    if env["vsproj"]:
+        if os.name != "nt":
+            print("Error: The `vsproj` option is only usable on Windows with Visual Studio.")
+            Exit(255)
+        env["CPPPATH"] = [Dir(path) for path in env["CPPPATH"]]
+        methods.generate_vs_project(env, GetOption("num_jobs"))
+        methods.generate_cpp_hint_file("cpp.hint")
+
+    # Check for the existence of headers
+    conf = Configure(env)
+    if "check_c_headers" in env:
+        for header in env["check_c_headers"]:
+            if conf.CheckCHeader(header[0]):
+                env.AppendUnique(CPPDEFINES=[header[1]])
+
+elif selected_platform != "":
+    if selected_platform == "list":
+        print("The following platforms are available:\n")
+    else:
+        print('Invalid target platform "' + selected_platform + '".')
+        print("The following platforms were detected:\n")
+
+    for x in platform_list:
+        print("\t" + x)
+
+    print("\nPlease run SCons again and select a valid platform: platform=<string>")
+
+    if selected_platform == "list":
+        # Exit early to suppress the rest of the built-in SCons messages
+        sys.exit(0)
+    else:
+        sys.exit(255)
+
+# The following only makes sense when the 'env' is defined, and assumes it is.
+if "env" in locals():
+    # FIXME: This method mixes both cosmetic progress stuff and cache handling...
+    methods.show_progress(env)
+    # TODO: replace this with `env.Dump(format="json")`
+    # once we start requiring SCons 4.0 as min version.
+    methods.dump(env)
+
+
+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)

SConstructGDNative

@@ -0,0 +1,105 @@
+#!python
+import os, subprocess
+
+opts = Variables([], ARGUMENTS)
+
+# Gets the standard flags CC, CCX, etc.
+env = DefaultEnvironment()
+
+# Define our options
+opts.Add(EnumVariable('target', "Compilation target", 'debug', ['d', 'debug', 'r', 'release']))
+opts.Add(EnumVariable('platform', "Compilation platform", '', ['', 'windows', 'x11', 'linux', 'osx']))
+opts.Add(EnumVariable('p', "Compilation target, alias for 'platform'", '', ['', 'windows', 'x11', 'linux', 'osx']))
+opts.Add(BoolVariable('use_llvm', "Use the LLVM / Clang compiler", 'no'))
+opts.Add(PathVariable('target_path', 'The path where the lib is installed.', '../game/gdn/'))
+opts.Add(PathVariable('target_name', 'The library name.', 'libgdexample', PathVariable.PathAccept))
+
+# Local dependency paths, adapt them to your setup
+godot_headers_path = "gdnative_cpp/pandemonium_headers/"
+cpp_bindings_path = "gdnative_cpp/"
+cpp_library = "libpandemonium-cpp"
+
+# only support 64 at this time..
+bits = 64
+
+# Updates the environment with the option variables.
+opts.Update(env)
+
+# Process some arguments
+if env['use_llvm']:
+    env['CC'] = 'clang'
+    env['CXX'] = 'clang++'
+
+if env['p'] != '':
+    env['platform'] = env['p']
+
+if env['platform'] == '':
+    print("No valid target platform selected.")
+    quit();
+
+# Check our platform specifics
+if env['platform'] == "osx":
+    env['target_path'] += 'osx/'
+    cpp_library += '.osx'
+    if env['target'] in ('debug', 'd'):
+        env.Append(CCFLAGS = ['-g','-O2', '-arch', 'x86_64', '-std=c++17'])
+        env.Append(LINKFLAGS = ['-arch', 'x86_64'])
+    else:
+        env.Append(CCFLAGS = ['-g','-O3', '-arch', 'x86_64', '-std=c++17'])
+        env.Append(LINKFLAGS = ['-arch', 'x86_64'])
+
+elif env['platform'] in ('x11', 'linux'):
+    env['target_path'] += 'x11/'
+    cpp_library += '.linux'
+    if env['target'] in ('debug', 'd'):
+        env.Append(CCFLAGS = ['-fPIC', '-g3','-Og', '-std=c++17'])
+    else:
+        env.Append(CCFLAGS = ['-fPIC', '-g','-O3', '-std=c++17'])
+
+elif env['platform'] == "windows":
+    env['target_path'] += 'win64/'
+    cpp_library += '.windows'
+    # This makes sure to keep the session environment variables on windows,
+    # that way you can run scons in a vs 2017 prompt and it will find all the required tools
+    env.Append(ENV = os.environ)
+
+    env.Append(CCFLAGS = ['-DWIN32', '-D_WIN32', '-D_WINDOWS', '-W3', '-GR', '-D_CRT_SECURE_NO_WARNINGS'])
+    if env['target'] in ('debug', 'd'):
+        env.Append(CCFLAGS = ['-EHsc', '-D_DEBUG', '-MDd'])
+    else:
+        env.Append(CCFLAGS = ['-O2', '-EHsc', '-DNDEBUG', '-MD'])
+
+if env['target'] in ('debug', 'd'):
+    cpp_library += '.debug'
+else:
+    cpp_library += '.release'
+
+cpp_library += '.' + str(bits)
+
+# make sure our binding library is properly includes
+env.Append(CPPPATH=['.', godot_headers_path, cpp_bindings_path, cpp_bindings_path + '/core/', cpp_bindings_path + '/gen/'])
+env.Append(LIBPATH=[cpp_bindings_path + 'bin/'])
+env.Append(LIBS=[cpp_library])
+
+env.Append(CCFLAGS = ['-DGDNATIVE'])
+
+# tweak this if you want to use different folders, or more folders, to store your source code in.
+#env.Append(CPPPATH=['src/'])
+#sources = Glob('src/*.cpp')
+
+sources = [
+    "gdlibrary.cpp",
+
+    "mlpp/lin_alg/mlpp_vector.cpp",
+    "mlpp/lin_alg/mlpp_matrix.cpp",
+    "mlpp/lin_alg/mlpp_tensor3.cpp",
+    "mlpp/lin_alg/lin_alg.cpp",
+
+]
+
+library = env.SharedLibrary(target=env['target_path'] + env['target_name'] , source=sources)
+
+Default(library)
+
+# Generates help for the -h scons option.
+Help(opts.GenerateHelpText(env))

sfw/SCsub

@@ -0,0 +1,209 @@
+#!/usr/bin/env python
+
+Import("env")
+
+import core_builders
+from platform_methods import run_in_subprocess
+
+env.core_sources = []
+
+
+# Generate AES256 script encryption key
+import os
+
+txt = "0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0"
+if "SCRIPT_AES256_ENCRYPTION_KEY" in os.environ:
+    key = os.environ["SCRIPT_AES256_ENCRYPTION_KEY"]
+    ec_valid = True
+    if len(key) != 64:
+        ec_valid = False
+    else:
+        txt = ""
+        for i in range(len(key) >> 1):
+            if i > 0:
+                txt += ","
+            txts = "0x" + key[i * 2 : i * 2 + 2]
+            try:
+                int(txts, 16)
+            except Exception:
+                ec_valid = False
+            txt += txts
+    if not ec_valid:
+        print("Error: Invalid AES256 encryption key, not 64 hexadecimal characters: '" + key + "'.")
+        print(
+            "Unset 'SCRIPT_AES256_ENCRYPTION_KEY' in your environment "
+            "or make sure that it contains exactly 64 hexadecimal characters."
+        )
+        Exit(255)
+
+# NOTE: It is safe to generate this file here, since this is still executed serially
+with open("script_encryption_key.gen.cpp", "w") as f:
+    f.write('#include "core/config/project_settings.h"\nuint8_t script_encryption_key[32]={' + txt + "};\n")
+
+
+# Add required thirdparty code.
+
+thirdparty_obj = []
+
+env_thirdparty = env.Clone()
+env_thirdparty.disable_warnings()
+
+# Misc thirdparty code: header paths are hardcoded, we don't need to append
+# to the include path (saves a few chars on the compiler invocation for touchy MSVC...)
+thirdparty_misc_dir = "#thirdparty/misc/"
+thirdparty_misc_sources = [
+    # C sources
+    "fastlz.c",
+    "smaz.c",
+    # C++ sources
+    "hq2x.cpp",
+    "pcg.cpp",
+    "triangulator.cpp",
+    "clipper.cpp",
+]
+thirdparty_misc_sources = [thirdparty_misc_dir + file for file in thirdparty_misc_sources]
+env_thirdparty.add_source_files(thirdparty_obj, thirdparty_misc_sources)
+
+# Zlib library, can be unbundled
+if env["builtin_zlib"]:
+    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_zlib_sources = [thirdparty_zlib_dir + file for file in thirdparty_zlib_sources]
+
+    env_thirdparty.Prepend(CPPPATH=[thirdparty_zlib_dir])
+    # Needs to be available in main env too
+    env.Prepend(CPPPATH=[thirdparty_zlib_dir])
+    if env["target"] == "debug":
+        env_thirdparty.Append(CPPDEFINES=["ZLIB_DEBUG"])
+
+    env_thirdparty.add_source_files(thirdparty_obj, thirdparty_zlib_sources)
+
+# Minizip library, could be unbundled in theory
+# However, our version has some custom modifications, so it won't compile with the system one
+thirdparty_minizip_dir = "#thirdparty/minizip/"
+thirdparty_minizip_sources = [
+    "ioapi.c",
+    "unzip.c",
+    "zip.c",
+]
+thirdparty_minizip_sources = [thirdparty_minizip_dir + file for file in thirdparty_minizip_sources]
+env_thirdparty.add_source_files(thirdparty_obj, thirdparty_minizip_sources)
+
+# Zstd library, can be unbundled in theory
+# though we currently use some private symbols
+# https://github.com/godotengine/godot/issues/17374
+if env["builtin_zstd"]:
+    thirdparty_zstd_dir = "#thirdparty/zstd/"
+    thirdparty_zstd_sources = [
+        "common/debug.c",
+        "common/entropy_common.c",
+        "common/error_private.c",
+        "common/fse_decompress.c",
+        "common/pool.c",
+        "common/threading.c",
+        "common/xxhash.c",
+        "common/zstd_common.c",
+        "compress/fse_compress.c",
+        "compress/hist.c",
+        "compress/huf_compress.c",
+        "compress/zstd_compress.c",
+        "compress/zstd_double_fast.c",
+        "compress/zstd_fast.c",
+        "compress/zstd_lazy.c",
+        "compress/zstd_ldm.c",
+        "compress/zstd_opt.c",
+        "compress/zstdmt_compress.c",
+        "compress/zstd_compress_literals.c",
+        "compress/zstd_compress_sequences.c",
+        "compress/zstd_compress_superblock.c",
+        "decompress/huf_decompress.c",
+        "decompress/zstd_ddict.c",
+        "decompress/zstd_decompress_block.c",
+        "decompress/zstd_decompress.c",
+    ]
+    
+    if env["platform"] in ["android", "iphone", "osx", "server", "x11"]:
+        # Match platforms with ZSTD_ASM_SUPPORTED in common/portability_macros.h
+        thirdparty_zstd_sources.append("decompress/huf_decompress_amd64.S")
+
+    thirdparty_zstd_sources = [thirdparty_zstd_dir + file for file in thirdparty_zstd_sources]
+
+    env_thirdparty.Prepend(CPPPATH=[thirdparty_zstd_dir, thirdparty_zstd_dir + "common"])
+    env_thirdparty.Append(CPPDEFINES=["ZSTD_STATIC_LINKING_ONLY"])
+    env.Prepend(CPPPATH=thirdparty_zstd_dir)
+    # Also needed in main env includes will trigger warnings
+    env.Append(CPPDEFINES=["ZSTD_STATIC_LINKING_ONLY"])
+
+    env_thirdparty.add_source_files(thirdparty_obj, thirdparty_zstd_sources)
+
+
+env.core_sources += thirdparty_obj
+
+
+# Pandemonium source files
+
+env.add_source_files(env.core_sources, "*.cpp")
+env.add_source_files(env.core_sources, "script_encryption_key.gen.cpp")
+env.add_source_files(env.core_sources, "version_hash.gen.cpp")
+
+# Certificates
+env.Depends(
+    "#core/io/certs_compressed.gen.h",
+    ["#thirdparty/certs/ca-certificates.crt", env.Value(env["builtin_certs"]), env.Value(env["system_certs_path"])],
+)
+env.CommandNoCache(
+    "#core/io/certs_compressed.gen.h",
+    "#thirdparty/certs/ca-certificates.crt",
+    run_in_subprocess(core_builders.make_certs_header),
+)
+
+# Authors
+env.Depends("#core/authors.gen.h", "../AUTHORS.md")
+env.CommandNoCache("#core/authors.gen.h", "../AUTHORS.md", run_in_subprocess(core_builders.make_authors_header))
+
+# Donors
+env.Depends("#core/donors.gen.h", "../DONORS.md")
+env.CommandNoCache("#core/donors.gen.h", "../DONORS.md", run_in_subprocess(core_builders.make_donors_header))
+
+license_files = [ "../LICENSE.txt", "../COPYRIGHT.txt" ]
+license_files.extend(env.module_license_files)
+
+# License
+env.Depends("#core/license.gen.h", license_files)
+env.CommandNoCache(
+    "#core/license.gen.h", license_files, run_in_subprocess(core_builders.make_license_header)
+)
+
+# Chain load SCsubs
+SConscript("os/SCsub")
+SConscript("math/SCsub")
+SConscript("string/SCsub")
+SConscript("containers/SCsub")
+SConscript("variant/SCsub")
+SConscript("error/SCsub")
+SConscript("config/SCsub")
+SConscript("crypto/SCsub")
+SConscript("io/SCsub")
+SConscript("log/SCsub")
+SConscript("object/SCsub")
+SConscript("input/SCsub")
+SConscript("bind/SCsub")
+
+# Build it all as a library
+lib = env.add_library("core", env.core_sources)
+env.Prepend(LIBS=[lib])
+
+# Needed to force rebuilding the core files when the thirdparty code is updated.
+env.Depends(lib, thirdparty_obj)