Started a Cobor Virtual Machine implementation for running the code.
This commit is contained in:
douwe
128
cobor_vm_extension/godot-cpp/tools/android.py
Normal file
128
cobor_vm_extension/godot-cpp/tools/android.py
Normal file
@@ -0,0 +1,128 @@
|
||||
import os
|
||||
import sys
|
||||
|
||||
import common_compiler_flags
|
||||
import my_spawn
|
||||
|
||||
|
||||
def options(opts):
|
||||
opts.Add(
|
||||
"android_api_level",
|
||||
"Target Android API level",
|
||||
"21",
|
||||
)
|
||||
opts.Add(
|
||||
"ANDROID_HOME",
|
||||
"Path to your Android SDK installation. By default, uses ANDROID_HOME from your defined environment variables.",
|
||||
os.environ.get("ANDROID_HOME", os.environ.get("ANDROID_SDK_ROOT")),
|
||||
)
|
||||
|
||||
|
||||
def exists(env):
|
||||
return get_android_ndk_root(env) is not None
|
||||
|
||||
|
||||
# This must be kept in sync with the value in https://github.com/godotengine/godot/blob/master/platform/android/detect.py#L58.
|
||||
def get_ndk_version():
|
||||
return "23.2.8568313"
|
||||
|
||||
|
||||
def get_android_ndk_root(env):
|
||||
if env["ANDROID_HOME"]:
|
||||
return env["ANDROID_HOME"] + "/ndk/" + get_ndk_version()
|
||||
else:
|
||||
return os.environ.get("ANDROID_NDK_ROOT")
|
||||
|
||||
|
||||
def generate(env):
|
||||
if get_android_ndk_root(env) is None:
|
||||
raise ValueError(
|
||||
"To build for Android, the path to the NDK must be defined. Please set ANDROID_HOME to the root folder of your Android SDK installation."
|
||||
)
|
||||
|
||||
if env["arch"] not in ("arm64", "x86_64", "arm32", "x86_32"):
|
||||
print("Only arm64, x86_64, arm32, and x86_32 are supported on Android. Exiting.")
|
||||
env.Exit(1)
|
||||
|
||||
if sys.platform == "win32" or sys.platform == "msys":
|
||||
my_spawn.configure(env)
|
||||
|
||||
# Validate API level
|
||||
if int(env["android_api_level"]) < 21:
|
||||
print("WARNING: minimum supported Android target api is 21. Forcing target api 21.")
|
||||
env["android_api_level"] = "21"
|
||||
|
||||
# Setup toolchain
|
||||
toolchain = get_android_ndk_root(env) + "/toolchains/llvm/prebuilt/"
|
||||
if sys.platform == "win32" or sys.platform == "msys":
|
||||
toolchain += "windows"
|
||||
import platform as pltfm
|
||||
|
||||
if pltfm.machine().endswith("64"):
|
||||
toolchain += "-x86_64"
|
||||
elif sys.platform.startswith("linux"):
|
||||
toolchain += "linux-x86_64"
|
||||
elif sys.platform == "darwin":
|
||||
toolchain += "darwin-x86_64"
|
||||
env.Append(LINKFLAGS=["-shared"])
|
||||
|
||||
if not os.path.exists(toolchain):
|
||||
print("ERROR: Could not find NDK toolchain at " + toolchain + ".")
|
||||
print("Make sure NDK version " + get_ndk_version() + " is installed.")
|
||||
env.Exit(1)
|
||||
|
||||
env.PrependENVPath("PATH", toolchain + "/bin") # This does nothing half of the time, but we'll put it here anyways
|
||||
|
||||
# Get architecture info
|
||||
arch_info_table = {
|
||||
"arm32": {
|
||||
"march": "armv7-a",
|
||||
"target": "armv7a-linux-androideabi",
|
||||
"compiler_path": "armv7a-linux-androideabi",
|
||||
"ccflags": ["-mfpu=neon"],
|
||||
},
|
||||
"arm64": {
|
||||
"march": "armv8-a",
|
||||
"target": "aarch64-linux-android",
|
||||
"compiler_path": "aarch64-linux-android",
|
||||
"ccflags": [],
|
||||
},
|
||||
"x86_32": {
|
||||
"march": "i686",
|
||||
"target": "i686-linux-android",
|
||||
"compiler_path": "i686-linux-android",
|
||||
"ccflags": ["-mstackrealign"],
|
||||
},
|
||||
"x86_64": {
|
||||
"march": "x86-64",
|
||||
"target": "x86_64-linux-android",
|
||||
"compiler_path": "x86_64-linux-android",
|
||||
"ccflags": [],
|
||||
},
|
||||
}
|
||||
arch_info = arch_info_table[env["arch"]]
|
||||
|
||||
# Setup tools
|
||||
env["CC"] = toolchain + "/bin/clang"
|
||||
env["CXX"] = toolchain + "/bin/clang++"
|
||||
env["LINK"] = toolchain + "/bin/clang++"
|
||||
env["AR"] = toolchain + "/bin/llvm-ar"
|
||||
env["AS"] = toolchain + "/bin/llvm-as"
|
||||
env["STRIP"] = toolchain + "/bin/llvm-strip"
|
||||
env["RANLIB"] = toolchain + "/bin/llvm-ranlib"
|
||||
env["SHLIBSUFFIX"] = ".so"
|
||||
|
||||
env.Append(
|
||||
CCFLAGS=["--target=" + arch_info["target"] + env["android_api_level"], "-march=" + arch_info["march"], "-fPIC"]
|
||||
)
|
||||
env.Append(CCFLAGS=arch_info["ccflags"])
|
||||
env.Append(LINKFLAGS=["--target=" + arch_info["target"] + env["android_api_level"], "-march=" + arch_info["march"]])
|
||||
|
||||
env.Append(CPPDEFINES=["ANDROID_ENABLED", "UNIX_ENABLED"])
|
||||
|
||||
# Refer to https://github.com/godotengine/godot/blob/master/platform/android/detect.py
|
||||
# LTO benefits for Android (size, performance) haven't been clearly established yet.
|
||||
if env["lto"] == "auto":
|
||||
env["lto"] = "none"
|
||||
|
||||
common_compiler_flags.generate(env)
|
||||
123
cobor_vm_extension/godot-cpp/tools/common_compiler_flags.py
Normal file
123
cobor_vm_extension/godot-cpp/tools/common_compiler_flags.py
Normal file
@@ -0,0 +1,123 @@
|
||||
import os
|
||||
import subprocess
|
||||
|
||||
|
||||
def using_clang(env):
|
||||
return "clang" in os.path.basename(env["CC"])
|
||||
|
||||
|
||||
def is_vanilla_clang(env):
|
||||
if not using_clang(env):
|
||||
return False
|
||||
try:
|
||||
version = subprocess.check_output([env.subst(env["CXX"]), "--version"]).strip().decode("utf-8")
|
||||
except (subprocess.CalledProcessError, OSError):
|
||||
print("Couldn't parse CXX environment variable to infer compiler version.")
|
||||
return False
|
||||
return not version.startswith("Apple")
|
||||
|
||||
|
||||
def exists(env):
|
||||
return True
|
||||
|
||||
|
||||
def generate(env):
|
||||
assert env["lto"] in ["thin", "full", "none"], "Unrecognized lto: {}".format(env["lto"])
|
||||
if env["lto"] != "none":
|
||||
print("Using LTO: " + env["lto"])
|
||||
|
||||
# Require C++17
|
||||
if env.get("is_msvc", False):
|
||||
env.Append(CXXFLAGS=["/std:c++17"])
|
||||
else:
|
||||
env.Append(CXXFLAGS=["-std=c++17"])
|
||||
|
||||
# Disable exception handling. Godot doesn't use exceptions anywhere, and this
|
||||
# saves around 20% of binary size and very significant build time.
|
||||
if env["disable_exceptions"]:
|
||||
if env.get("is_msvc", False):
|
||||
env.Append(CPPDEFINES=[("_HAS_EXCEPTIONS", 0)])
|
||||
else:
|
||||
env.Append(CXXFLAGS=["-fno-exceptions"])
|
||||
elif env.get("is_msvc", False):
|
||||
env.Append(CXXFLAGS=["/EHsc"])
|
||||
|
||||
if not env.get("is_msvc", False):
|
||||
if env["symbols_visibility"] == "visible":
|
||||
env.Append(CCFLAGS=["-fvisibility=default"])
|
||||
env.Append(LINKFLAGS=["-fvisibility=default"])
|
||||
elif env["symbols_visibility"] == "hidden":
|
||||
env.Append(CCFLAGS=["-fvisibility=hidden"])
|
||||
env.Append(LINKFLAGS=["-fvisibility=hidden"])
|
||||
|
||||
# Set optimize and debug_symbols flags.
|
||||
# "custom" means do nothing and let users set their own optimization flags.
|
||||
if env.get("is_msvc", False):
|
||||
if env["debug_symbols"]:
|
||||
env.Append(CCFLAGS=["/Zi", "/FS"])
|
||||
env.Append(LINKFLAGS=["/DEBUG:FULL"])
|
||||
|
||||
if env["optimize"] == "speed":
|
||||
env.Append(CCFLAGS=["/O2"])
|
||||
env.Append(LINKFLAGS=["/OPT:REF"])
|
||||
elif env["optimize"] == "speed_trace":
|
||||
env.Append(CCFLAGS=["/O2"])
|
||||
env.Append(LINKFLAGS=["/OPT:REF", "/OPT:NOICF"])
|
||||
elif env["optimize"] == "size":
|
||||
env.Append(CCFLAGS=["/O1"])
|
||||
env.Append(LINKFLAGS=["/OPT:REF"])
|
||||
elif env["optimize"] == "debug" or env["optimize"] == "none":
|
||||
env.Append(CCFLAGS=["/Od"])
|
||||
|
||||
if env["lto"] == "thin":
|
||||
if not env["use_llvm"]:
|
||||
print("ThinLTO is only compatible with LLVM, use `use_llvm=yes` or `lto=full`.")
|
||||
env.Exit(255)
|
||||
|
||||
env.Append(CCFLAGS=["-flto=thin"])
|
||||
env.Append(LINKFLAGS=["-flto=thin"])
|
||||
elif env["lto"] == "full":
|
||||
if env["use_llvm"]:
|
||||
env.Append(CCFLAGS=["-flto"])
|
||||
env.Append(LINKFLAGS=["-flto"])
|
||||
else:
|
||||
env.AppendUnique(CCFLAGS=["/GL"])
|
||||
env.AppendUnique(ARFLAGS=["/LTCG"])
|
||||
env.AppendUnique(LINKFLAGS=["/LTCG"])
|
||||
else:
|
||||
if env["debug_symbols"]:
|
||||
# Adding dwarf-4 explicitly makes stacktraces work with clang builds,
|
||||
# otherwise addr2line doesn't understand them.
|
||||
env.Append(CCFLAGS=["-gdwarf-4"])
|
||||
if env.dev_build:
|
||||
env.Append(CCFLAGS=["-g3"])
|
||||
else:
|
||||
env.Append(CCFLAGS=["-g2"])
|
||||
else:
|
||||
if using_clang(env) and not is_vanilla_clang(env) and not env["use_mingw"]:
|
||||
# Apple Clang, its linker doesn't like -s.
|
||||
env.Append(LINKFLAGS=["-Wl,-S", "-Wl,-x", "-Wl,-dead_strip"])
|
||||
else:
|
||||
env.Append(LINKFLAGS=["-s"])
|
||||
|
||||
if env["optimize"] == "speed":
|
||||
env.Append(CCFLAGS=["-O3"])
|
||||
# `-O2` is friendlier to debuggers than `-O3`, leading to better crash backtraces.
|
||||
elif env["optimize"] == "speed_trace":
|
||||
env.Append(CCFLAGS=["-O2"])
|
||||
elif env["optimize"] == "size":
|
||||
env.Append(CCFLAGS=["-Os"])
|
||||
elif env["optimize"] == "debug":
|
||||
env.Append(CCFLAGS=["-Og"])
|
||||
elif env["optimize"] == "none":
|
||||
env.Append(CCFLAGS=["-O0"])
|
||||
|
||||
if env["lto"] == "thin":
|
||||
if (env["platform"] == "windows" or env["platform"] == "linux") and not env["use_llvm"]:
|
||||
print("ThinLTO is only compatible with LLVM, use `use_llvm=yes` or `lto=full`.")
|
||||
env.Exit(255)
|
||||
env.Append(CCFLAGS=["-flto=thin"])
|
||||
env.Append(LINKFLAGS=["-flto=thin"])
|
||||
elif env["lto"] == "full":
|
||||
env.Append(CCFLAGS=["-flto"])
|
||||
env.Append(LINKFLAGS=["-flto"])
|
||||
562
cobor_vm_extension/godot-cpp/tools/godotcpp.py
Normal file
562
cobor_vm_extension/godot-cpp/tools/godotcpp.py
Normal file
@@ -0,0 +1,562 @@
|
||||
import os
|
||||
import platform
|
||||
import sys
|
||||
|
||||
from SCons.Action import Action
|
||||
from SCons.Builder import Builder
|
||||
from SCons.Errors import UserError
|
||||
from SCons.Script import ARGUMENTS
|
||||
from SCons.Tool import Tool
|
||||
from SCons.Variables import BoolVariable, EnumVariable, PathVariable
|
||||
from SCons.Variables.BoolVariable import _text2bool
|
||||
|
||||
from binding_generator import _generate_bindings, _get_file_list, get_file_list
|
||||
from build_profile import generate_trimmed_api
|
||||
from doc_source_generator import scons_generate_doc_source
|
||||
|
||||
|
||||
def add_sources(sources, dir, extension):
|
||||
for f in os.listdir(dir):
|
||||
if f.endswith("." + extension):
|
||||
sources.append(dir + "/" + f)
|
||||
|
||||
|
||||
def get_cmdline_bool(option, default):
|
||||
"""We use `ARGUMENTS.get()` to check if options were manually overridden on the command line,
|
||||
and SCons' _text2bool helper to convert them to booleans, otherwise they're handled as strings.
|
||||
"""
|
||||
cmdline_val = ARGUMENTS.get(option)
|
||||
if cmdline_val is not None:
|
||||
return _text2bool(cmdline_val)
|
||||
else:
|
||||
return default
|
||||
|
||||
|
||||
def normalize_path(val, env):
|
||||
return val if os.path.isabs(val) else os.path.join(env.Dir("#").abspath, val)
|
||||
|
||||
|
||||
def validate_file(key, val, env):
|
||||
if not os.path.isfile(normalize_path(val, env)):
|
||||
raise UserError("'%s' is not a file: %s" % (key, val))
|
||||
|
||||
|
||||
def validate_dir(key, val, env):
|
||||
if not os.path.isdir(normalize_path(val, env)):
|
||||
raise UserError("'%s' is not a directory: %s" % (key, val))
|
||||
|
||||
|
||||
def validate_parent_dir(key, val, env):
|
||||
if not os.path.isdir(normalize_path(os.path.dirname(val), env)):
|
||||
raise UserError("'%s' is not a directory: %s" % (key, os.path.dirname(val)))
|
||||
|
||||
|
||||
def get_platform_tools_paths(env):
|
||||
path = env.get("custom_tools", None)
|
||||
if path is None:
|
||||
return ["tools"]
|
||||
return [normalize_path(path, env), "tools"]
|
||||
|
||||
|
||||
def get_custom_platforms(env):
|
||||
path = env.get("custom_tools", None)
|
||||
if path is None:
|
||||
return []
|
||||
platforms = []
|
||||
for x in os.listdir(normalize_path(path, env)):
|
||||
if not x.endswith(".py"):
|
||||
continue
|
||||
platforms.append(x.removesuffix(".py"))
|
||||
return platforms
|
||||
|
||||
|
||||
def no_verbose(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"]
|
||||
)
|
||||
compiled_resource_message = "{}Creating Compiled Resource {}$TARGET{} ...{}".format(
|
||||
colors["blue"], colors["bold_blue"], colors["blue"], colors["reset"]
|
||||
)
|
||||
generated_file_message = "{}Generating {}$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])
|
||||
env.Append(RCCOMSTR=[compiled_resource_message])
|
||||
env.Append(GENCOMSTR=[generated_file_message])
|
||||
|
||||
|
||||
def scons_emit_files(target, source, env):
|
||||
profile_filepath = env.get("build_profile", "")
|
||||
if profile_filepath:
|
||||
profile_filepath = normalize_path(profile_filepath, env)
|
||||
|
||||
# Always clean all files
|
||||
env.Clean(target, [env.File(f) for f in get_file_list(str(source[0]), target[0].abspath, True, True)])
|
||||
|
||||
api = generate_trimmed_api(str(source[0]), profile_filepath)
|
||||
files = [env.File(f) for f in _get_file_list(api, target[0].abspath, True, True)]
|
||||
env["godot_cpp_gen_dir"] = target[0].abspath
|
||||
return files, source
|
||||
|
||||
|
||||
def scons_generate_bindings(target, source, env):
|
||||
profile_filepath = env.get("build_profile", "")
|
||||
if profile_filepath:
|
||||
profile_filepath = normalize_path(profile_filepath, env)
|
||||
|
||||
api = generate_trimmed_api(str(source[0]), profile_filepath)
|
||||
|
||||
_generate_bindings(
|
||||
api,
|
||||
str(source[0]),
|
||||
env["generate_template_get_node"],
|
||||
"32" if "32" in env["arch"] else "64",
|
||||
env["precision"],
|
||||
env["godot_cpp_gen_dir"],
|
||||
)
|
||||
return None
|
||||
|
||||
|
||||
platforms = ["linux", "macos", "windows", "android", "ios", "web"]
|
||||
|
||||
# CPU architecture options.
|
||||
architecture_array = [
|
||||
"",
|
||||
"universal",
|
||||
"x86_32",
|
||||
"x86_64",
|
||||
"arm32",
|
||||
"arm64",
|
||||
"rv64",
|
||||
"ppc32",
|
||||
"ppc64",
|
||||
"wasm32",
|
||||
]
|
||||
architecture_aliases = {
|
||||
"x64": "x86_64",
|
||||
"amd64": "x86_64",
|
||||
"armv7": "arm32",
|
||||
"armv8": "arm64",
|
||||
"arm64v8": "arm64",
|
||||
"aarch64": "arm64",
|
||||
"rv": "rv64",
|
||||
"riscv": "rv64",
|
||||
"riscv64": "rv64",
|
||||
"ppcle": "ppc32",
|
||||
"ppc": "ppc32",
|
||||
"ppc64le": "ppc64",
|
||||
}
|
||||
|
||||
|
||||
def exists(env):
|
||||
return True
|
||||
|
||||
|
||||
def options(opts, env):
|
||||
# Try to detect the host platform automatically.
|
||||
# This is used if no `platform` argument is passed
|
||||
if sys.platform.startswith("linux"):
|
||||
default_platform = "linux"
|
||||
elif sys.platform == "darwin":
|
||||
default_platform = "macos"
|
||||
elif sys.platform == "win32" or sys.platform == "msys":
|
||||
default_platform = "windows"
|
||||
elif ARGUMENTS.get("platform", ""):
|
||||
default_platform = ARGUMENTS.get("platform")
|
||||
else:
|
||||
raise ValueError("Could not detect platform automatically, please specify with platform=<platform>")
|
||||
|
||||
opts.Add(
|
||||
PathVariable(
|
||||
key="custom_tools",
|
||||
help="Path to directory containing custom tools",
|
||||
default=env.get("custom_tools", None),
|
||||
validator=validate_dir,
|
||||
)
|
||||
)
|
||||
|
||||
opts.Update(env)
|
||||
|
||||
custom_platforms = get_custom_platforms(env)
|
||||
|
||||
opts.Add(
|
||||
EnumVariable(
|
||||
key="platform",
|
||||
help="Target platform",
|
||||
default=env.get("platform", default_platform),
|
||||
allowed_values=platforms + custom_platforms,
|
||||
ignorecase=2,
|
||||
)
|
||||
)
|
||||
|
||||
# Editor and template_debug are compatible (i.e. you can use the same binary for Godot editor builds and Godot debug templates).
|
||||
# Godot release templates are only compatible with "template_release" builds.
|
||||
# For this reason, we default to template_debug builds, unlike Godot which defaults to editor builds.
|
||||
opts.Add(
|
||||
EnumVariable(
|
||||
key="target",
|
||||
help="Compilation target",
|
||||
default=env.get("target", "template_debug"),
|
||||
allowed_values=("editor", "template_release", "template_debug"),
|
||||
)
|
||||
)
|
||||
opts.Add(
|
||||
PathVariable(
|
||||
key="gdextension_dir",
|
||||
help="Path to a custom directory containing GDExtension interface header and API JSON file",
|
||||
default=env.get("gdextension_dir", None),
|
||||
validator=validate_dir,
|
||||
)
|
||||
)
|
||||
opts.Add(
|
||||
PathVariable(
|
||||
key="custom_api_file",
|
||||
help="Path to a custom GDExtension API JSON file (takes precedence over `gdextension_dir`)",
|
||||
default=env.get("custom_api_file", None),
|
||||
validator=validate_file,
|
||||
)
|
||||
)
|
||||
opts.Add(
|
||||
BoolVariable(
|
||||
key="generate_bindings",
|
||||
help="Force GDExtension API bindings generation. Auto-detected by default.",
|
||||
default=env.get("generate_bindings", False),
|
||||
)
|
||||
)
|
||||
opts.Add(
|
||||
BoolVariable(
|
||||
key="generate_template_get_node",
|
||||
help="Generate a template version of the Node class's get_node.",
|
||||
default=env.get("generate_template_get_node", True),
|
||||
)
|
||||
)
|
||||
opts.Add(
|
||||
BoolVariable(
|
||||
key="build_library",
|
||||
help="Build the godot-cpp library.",
|
||||
default=env.get("build_library", True),
|
||||
)
|
||||
)
|
||||
opts.Add(
|
||||
EnumVariable(
|
||||
key="precision",
|
||||
help="Set the floating-point precision level",
|
||||
default=env.get("precision", "single"),
|
||||
allowed_values=("single", "double"),
|
||||
)
|
||||
)
|
||||
opts.Add(
|
||||
EnumVariable(
|
||||
key="arch",
|
||||
help="CPU architecture",
|
||||
default=env.get("arch", ""),
|
||||
allowed_values=architecture_array,
|
||||
map=architecture_aliases,
|
||||
)
|
||||
)
|
||||
|
||||
opts.Add(BoolVariable(key="threads", help="Enable threading support", default=env.get("threads", True)))
|
||||
|
||||
# compiledb
|
||||
opts.Add(
|
||||
BoolVariable(
|
||||
key="compiledb",
|
||||
help="Generate compilation DB (`compile_commands.json`) for external tools",
|
||||
default=env.get("compiledb", False),
|
||||
)
|
||||
)
|
||||
opts.Add(
|
||||
PathVariable(
|
||||
key="compiledb_file",
|
||||
help="Path to a custom `compile_commands.json` file",
|
||||
default=env.get("compiledb_file", "compile_commands.json"),
|
||||
validator=validate_parent_dir,
|
||||
)
|
||||
)
|
||||
|
||||
opts.Add(
|
||||
PathVariable(
|
||||
"build_profile",
|
||||
"Path to a file containing a feature build profile",
|
||||
default=env.get("build_profile", None),
|
||||
validator=validate_file,
|
||||
)
|
||||
)
|
||||
|
||||
opts.Add(
|
||||
BoolVariable(
|
||||
key="use_hot_reload",
|
||||
help="Enable the extra accounting required to support hot reload.",
|
||||
default=env.get("use_hot_reload", None),
|
||||
)
|
||||
)
|
||||
|
||||
opts.Add(
|
||||
BoolVariable(
|
||||
"disable_exceptions", "Force disabling exception handling code", default=env.get("disable_exceptions", True)
|
||||
)
|
||||
)
|
||||
|
||||
opts.Add(
|
||||
EnumVariable(
|
||||
key="symbols_visibility",
|
||||
help="Symbols visibility on GNU platforms. Use 'auto' to apply the default value.",
|
||||
default=env.get("symbols_visibility", "hidden"),
|
||||
allowed_values=["auto", "visible", "hidden"],
|
||||
)
|
||||
)
|
||||
|
||||
opts.Add(
|
||||
EnumVariable(
|
||||
"optimize",
|
||||
"The desired optimization flags",
|
||||
"speed_trace",
|
||||
("none", "custom", "debug", "speed", "speed_trace", "size"),
|
||||
)
|
||||
)
|
||||
opts.Add(
|
||||
EnumVariable(
|
||||
"lto",
|
||||
"Link-time optimization",
|
||||
"none",
|
||||
("none", "auto", "thin", "full"),
|
||||
)
|
||||
)
|
||||
opts.Add(BoolVariable("debug_symbols", "Build with debugging symbols", True))
|
||||
opts.Add(BoolVariable("dev_build", "Developer build with dev-only debugging code (DEV_ENABLED)", False))
|
||||
opts.Add(BoolVariable("verbose", "Enable verbose output for the compilation", False))
|
||||
|
||||
# Add platform options (custom tools can override platforms)
|
||||
for pl in sorted(set(platforms + custom_platforms)):
|
||||
tool = Tool(pl, toolpath=get_platform_tools_paths(env))
|
||||
if hasattr(tool, "options"):
|
||||
tool.options(opts)
|
||||
|
||||
|
||||
def generate(env):
|
||||
# Default num_jobs to local cpu count if not user specified.
|
||||
# SCons has a peculiarity where user-specified options won't be overridden
|
||||
# by SetOption, so we can rely on this to know if we should use our default.
|
||||
initial_num_jobs = env.GetOption("num_jobs")
|
||||
altered_num_jobs = initial_num_jobs + 1
|
||||
env.SetOption("num_jobs", altered_num_jobs)
|
||||
if env.GetOption("num_jobs") == altered_num_jobs:
|
||||
cpu_count = os.cpu_count()
|
||||
if cpu_count is None:
|
||||
print("Couldn't auto-detect CPU count to configure build parallelism. Specify it with the -j argument.")
|
||||
else:
|
||||
safer_cpu_count = cpu_count if cpu_count <= 4 else cpu_count - 1
|
||||
print(
|
||||
"Auto-detected %d CPU cores available for build parallelism. Using %d cores by default. You can override it with the -j argument."
|
||||
% (cpu_count, safer_cpu_count)
|
||||
)
|
||||
env.SetOption("num_jobs", safer_cpu_count)
|
||||
|
||||
# Process CPU architecture argument.
|
||||
if env["arch"] == "":
|
||||
# No architecture specified. Default to arm64 if building for Android,
|
||||
# universal if building for macOS or iOS, wasm32 if building for web,
|
||||
# otherwise default to the host architecture.
|
||||
if env["platform"] in ["macos", "ios"]:
|
||||
env["arch"] = "universal"
|
||||
elif env["platform"] == "android":
|
||||
env["arch"] = "arm64"
|
||||
elif env["platform"] == "web":
|
||||
env["arch"] = "wasm32"
|
||||
else:
|
||||
host_machine = platform.machine().lower()
|
||||
if host_machine in architecture_array:
|
||||
env["arch"] = host_machine
|
||||
elif host_machine in architecture_aliases.keys():
|
||||
env["arch"] = architecture_aliases[host_machine]
|
||||
elif "86" in host_machine:
|
||||
# Catches x86, i386, i486, i586, i686, etc.
|
||||
env["arch"] = "x86_32"
|
||||
else:
|
||||
print("Unsupported CPU architecture: " + host_machine)
|
||||
env.Exit(1)
|
||||
|
||||
print("Building for architecture " + env["arch"] + " on platform " + env["platform"])
|
||||
|
||||
# These defaults may be needed by platform tools
|
||||
env.use_hot_reload = env.get("use_hot_reload", env["target"] != "template_release")
|
||||
env.editor_build = env["target"] == "editor"
|
||||
env.dev_build = env["dev_build"]
|
||||
env.debug_features = env["target"] in ["editor", "template_debug"]
|
||||
|
||||
if env.dev_build:
|
||||
opt_level = "none"
|
||||
elif env.debug_features:
|
||||
opt_level = "speed_trace"
|
||||
else: # Release
|
||||
opt_level = "speed"
|
||||
|
||||
env["optimize"] = ARGUMENTS.get("optimize", opt_level)
|
||||
env["debug_symbols"] = get_cmdline_bool("debug_symbols", env.dev_build)
|
||||
|
||||
tool = Tool(env["platform"], toolpath=get_platform_tools_paths(env))
|
||||
|
||||
if tool is None or not tool.exists(env):
|
||||
raise ValueError("Required toolchain not found for platform " + env["platform"])
|
||||
|
||||
tool.generate(env)
|
||||
|
||||
if env["threads"]:
|
||||
env.Append(CPPDEFINES=["THREADS_ENABLED"])
|
||||
|
||||
if env.use_hot_reload:
|
||||
env.Append(CPPDEFINES=["HOT_RELOAD_ENABLED"])
|
||||
|
||||
if env.editor_build:
|
||||
env.Append(CPPDEFINES=["TOOLS_ENABLED"])
|
||||
|
||||
# Configuration of build targets:
|
||||
# - Editor or template
|
||||
# - Debug features (DEBUG_ENABLED code)
|
||||
# - Dev only code (DEV_ENABLED code)
|
||||
# - Optimization level
|
||||
# - Debug symbols for crash traces / debuggers
|
||||
# Keep this configuration in sync with SConstruct in upstream Godot.
|
||||
if env.debug_features:
|
||||
# DEBUG_ENABLED enables debugging *features* and debug-only code, which is intended
|
||||
# to give *users* extra debugging information for their game development.
|
||||
env.Append(CPPDEFINES=["DEBUG_ENABLED"])
|
||||
# In upstream Godot this is added in typedefs.h when DEBUG_ENABLED is set.
|
||||
env.Append(CPPDEFINES=["DEBUG_METHODS_ENABLED"])
|
||||
|
||||
if env.dev_build:
|
||||
# DEV_ENABLED enables *engine developer* code which should only be compiled for those
|
||||
# working on the engine itself.
|
||||
env.Append(CPPDEFINES=["DEV_ENABLED"])
|
||||
else:
|
||||
# Disable assert() for production targets (only used in thirdparty code).
|
||||
env.Append(CPPDEFINES=["NDEBUG"])
|
||||
|
||||
if env["precision"] == "double":
|
||||
env.Append(CPPDEFINES=["REAL_T_IS_DOUBLE"])
|
||||
|
||||
# Allow detecting when building as a GDExtension.
|
||||
env.Append(CPPDEFINES=["GDEXTENSION"])
|
||||
|
||||
# Suffix
|
||||
suffix = ".{}.{}".format(env["platform"], env["target"])
|
||||
if env.dev_build:
|
||||
suffix += ".dev"
|
||||
if env["precision"] == "double":
|
||||
suffix += ".double"
|
||||
suffix += "." + env["arch"]
|
||||
if env["ios_simulator"]:
|
||||
suffix += ".simulator"
|
||||
if not env["threads"]:
|
||||
suffix += ".nothreads"
|
||||
|
||||
env["suffix"] = suffix # Exposed when included from another project
|
||||
env["OBJSUFFIX"] = suffix + env["OBJSUFFIX"]
|
||||
|
||||
# compile_commands.json
|
||||
env.Tool("compilation_db")
|
||||
env.Alias("compiledb", env.CompilationDatabase(normalize_path(env["compiledb_file"], env)))
|
||||
|
||||
# Formatting
|
||||
if not env["verbose"]:
|
||||
no_verbose(env)
|
||||
|
||||
# Builders
|
||||
env.Append(
|
||||
BUILDERS={
|
||||
"GodotCPPBindings": Builder(action=Action(scons_generate_bindings, "$GENCOMSTR"), emitter=scons_emit_files),
|
||||
"GodotCPPDocData": Builder(action=scons_generate_doc_source),
|
||||
}
|
||||
)
|
||||
env.AddMethod(_godot_cpp, "GodotCPP")
|
||||
|
||||
|
||||
def _godot_cpp(env):
|
||||
extension_dir = normalize_path(env.get("gdextension_dir", env.Dir("gdextension").abspath), env)
|
||||
api_file = normalize_path(env.get("custom_api_file", env.File(extension_dir + "/extension_api.json").abspath), env)
|
||||
bindings = env.GodotCPPBindings(
|
||||
env.Dir("."),
|
||||
[
|
||||
api_file,
|
||||
os.path.join(extension_dir, "gdextension_interface.h"),
|
||||
"binding_generator.py",
|
||||
],
|
||||
)
|
||||
# Forces bindings regeneration.
|
||||
if env["generate_bindings"]:
|
||||
env.AlwaysBuild(bindings)
|
||||
env.NoCache(bindings)
|
||||
|
||||
# Sources to compile
|
||||
sources = []
|
||||
add_sources(sources, "src", "cpp")
|
||||
add_sources(sources, "src/classes", "cpp")
|
||||
add_sources(sources, "src/core", "cpp")
|
||||
add_sources(sources, "src/variant", "cpp")
|
||||
sources.extend([f for f in bindings if str(f).endswith(".cpp")])
|
||||
|
||||
# Includes
|
||||
env.AppendUnique(CPPPATH=[env.Dir(d) for d in [extension_dir, "include", "gen/include"]])
|
||||
|
||||
library = None
|
||||
library_name = "libgodot-cpp" + env["suffix"] + env["LIBSUFFIX"]
|
||||
|
||||
if env["build_library"]:
|
||||
library = env.StaticLibrary(target=env.File("bin/%s" % library_name), source=sources)
|
||||
env.NoCache(library)
|
||||
default_args = [library]
|
||||
|
||||
# Add compiledb if the option is set
|
||||
if env.get("compiledb", False):
|
||||
default_args += ["compiledb"]
|
||||
|
||||
env.Default(*default_args)
|
||||
|
||||
env.AppendUnique(LIBS=[env.File("bin/%s" % library_name)])
|
||||
return library
|
||||
105
cobor_vm_extension/godot-cpp/tools/ios.py
Normal file
105
cobor_vm_extension/godot-cpp/tools/ios.py
Normal file
@@ -0,0 +1,105 @@
|
||||
import codecs
|
||||
import os
|
||||
import subprocess
|
||||
import sys
|
||||
|
||||
import common_compiler_flags
|
||||
from SCons.Variables import BoolVariable
|
||||
|
||||
|
||||
def has_ios_osxcross():
|
||||
return "OSXCROSS_IOS" in os.environ
|
||||
|
||||
|
||||
def options(opts):
|
||||
opts.Add(BoolVariable("ios_simulator", "Target iOS Simulator", False))
|
||||
opts.Add("ios_min_version", "Target minimum iphoneos/iphonesimulator version", "12.0")
|
||||
opts.Add(
|
||||
"IOS_TOOLCHAIN_PATH",
|
||||
"Path to iOS toolchain",
|
||||
"/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain",
|
||||
)
|
||||
opts.Add("IOS_SDK_PATH", "Path to the iOS SDK", "")
|
||||
|
||||
if has_ios_osxcross():
|
||||
opts.Add("ios_triple", "Triple for ios toolchain", "")
|
||||
|
||||
|
||||
def exists(env):
|
||||
return sys.platform == "darwin" or has_ios_osxcross()
|
||||
|
||||
|
||||
def generate(env):
|
||||
if env["arch"] not in ("universal", "arm64", "x86_64"):
|
||||
raise ValueError("Only universal, arm64, and x86_64 are supported on iOS. Exiting.")
|
||||
|
||||
if env["ios_simulator"]:
|
||||
sdk_name = "iphonesimulator"
|
||||
env.Append(CCFLAGS=["-mios-simulator-version-min=" + env["ios_min_version"]])
|
||||
else:
|
||||
sdk_name = "iphoneos"
|
||||
env.Append(CCFLAGS=["-miphoneos-version-min=" + env["ios_min_version"]])
|
||||
|
||||
if sys.platform == "darwin":
|
||||
if env["IOS_SDK_PATH"] == "":
|
||||
try:
|
||||
env["IOS_SDK_PATH"] = codecs.utf_8_decode(
|
||||
subprocess.check_output(["xcrun", "--sdk", sdk_name, "--show-sdk-path"]).strip()
|
||||
)[0]
|
||||
except (subprocess.CalledProcessError, OSError):
|
||||
raise ValueError(
|
||||
"Failed to find SDK path while running xcrun --sdk {} --show-sdk-path.".format(sdk_name)
|
||||
)
|
||||
|
||||
compiler_path = env["IOS_TOOLCHAIN_PATH"] + "/usr/bin/"
|
||||
env["CC"] = compiler_path + "clang"
|
||||
env["CXX"] = compiler_path + "clang++"
|
||||
env["AR"] = compiler_path + "ar"
|
||||
env["RANLIB"] = compiler_path + "ranlib"
|
||||
env["SHLIBSUFFIX"] = ".dylib"
|
||||
env["ENV"]["PATH"] = env["IOS_TOOLCHAIN_PATH"] + "/Developer/usr/bin/:" + env["ENV"]["PATH"]
|
||||
|
||||
else:
|
||||
# OSXCross
|
||||
compiler_path = "$IOS_TOOLCHAIN_PATH/usr/bin/${ios_triple}"
|
||||
env["CC"] = compiler_path + "clang"
|
||||
env["CXX"] = compiler_path + "clang++"
|
||||
env["AR"] = compiler_path + "ar"
|
||||
env["RANLIB"] = compiler_path + "ranlib"
|
||||
env["SHLIBSUFFIX"] = ".dylib"
|
||||
|
||||
env.Prepend(
|
||||
CPPPATH=[
|
||||
"$IOS_SDK_PATH/usr/include",
|
||||
"$IOS_SDK_PATH/System/Library/Frameworks/AudioUnit.framework/Headers",
|
||||
]
|
||||
)
|
||||
|
||||
env.Append(CCFLAGS=["-stdlib=libc++"])
|
||||
|
||||
binpath = os.path.join(env["IOS_TOOLCHAIN_PATH"], "usr", "bin")
|
||||
if binpath not in env["ENV"]["PATH"]:
|
||||
env.PrependENVPath("PATH", binpath)
|
||||
|
||||
if env["arch"] == "universal":
|
||||
if env["ios_simulator"]:
|
||||
env.Append(LINKFLAGS=["-arch", "x86_64", "-arch", "arm64"])
|
||||
env.Append(CCFLAGS=["-arch", "x86_64", "-arch", "arm64"])
|
||||
else:
|
||||
env.Append(LINKFLAGS=["-arch", "arm64"])
|
||||
env.Append(CCFLAGS=["-arch", "arm64"])
|
||||
else:
|
||||
env.Append(LINKFLAGS=["-arch", env["arch"]])
|
||||
env.Append(CCFLAGS=["-arch", env["arch"]])
|
||||
|
||||
env.Append(CCFLAGS=["-isysroot", env["IOS_SDK_PATH"]])
|
||||
env.Append(LINKFLAGS=["-isysroot", env["IOS_SDK_PATH"], "-F" + env["IOS_SDK_PATH"]])
|
||||
|
||||
env.Append(CPPDEFINES=["IOS_ENABLED", "UNIX_ENABLED"])
|
||||
|
||||
# Refer to https://github.com/godotengine/godot/blob/master/platform/ios/detect.py:
|
||||
# Disable by default as it makes linking in Xcode very slow.
|
||||
if env["lto"] == "auto":
|
||||
env["lto"] = "none"
|
||||
|
||||
common_compiler_flags.generate(env)
|
||||
46
cobor_vm_extension/godot-cpp/tools/linux.py
Normal file
46
cobor_vm_extension/godot-cpp/tools/linux.py
Normal file
@@ -0,0 +1,46 @@
|
||||
import common_compiler_flags
|
||||
from SCons.Tool import clang, clangxx
|
||||
from SCons.Variables import BoolVariable
|
||||
|
||||
|
||||
def options(opts):
|
||||
opts.Add(BoolVariable("use_llvm", "Use the LLVM compiler - only effective when targeting Linux", False))
|
||||
|
||||
|
||||
def exists(env):
|
||||
return True
|
||||
|
||||
|
||||
def generate(env):
|
||||
if env["use_llvm"]:
|
||||
clang.generate(env)
|
||||
clangxx.generate(env)
|
||||
elif env.use_hot_reload:
|
||||
# Required for extensions to truly unload.
|
||||
env.Append(CXXFLAGS=["-fno-gnu-unique"])
|
||||
|
||||
env.Append(CCFLAGS=["-fPIC", "-Wwrite-strings"])
|
||||
env.Append(LINKFLAGS=["-Wl,-R,'$$ORIGIN'"])
|
||||
|
||||
if env["arch"] == "x86_64":
|
||||
# -m64 and -m32 are x86-specific already, but it doesn't hurt to
|
||||
# be clear and also specify -march=x86-64. Similar with 32-bit.
|
||||
env.Append(CCFLAGS=["-m64", "-march=x86-64"])
|
||||
env.Append(LINKFLAGS=["-m64", "-march=x86-64"])
|
||||
elif env["arch"] == "x86_32":
|
||||
env.Append(CCFLAGS=["-m32", "-march=i686"])
|
||||
env.Append(LINKFLAGS=["-m32", "-march=i686"])
|
||||
elif env["arch"] == "arm64":
|
||||
env.Append(CCFLAGS=["-march=armv8-a"])
|
||||
env.Append(LINKFLAGS=["-march=armv8-a"])
|
||||
elif env["arch"] == "rv64":
|
||||
env.Append(CCFLAGS=["-march=rv64gc"])
|
||||
env.Append(LINKFLAGS=["-march=rv64gc"])
|
||||
|
||||
env.Append(CPPDEFINES=["LINUX_ENABLED", "UNIX_ENABLED"])
|
||||
|
||||
# Refer to https://github.com/godotengine/godot/blob/master/platform/linuxbsd/detect.py
|
||||
if env["lto"] == "auto":
|
||||
env["lto"] = "full"
|
||||
|
||||
common_compiler_flags.generate(env)
|
||||
81
cobor_vm_extension/godot-cpp/tools/macos.py
Normal file
81
cobor_vm_extension/godot-cpp/tools/macos.py
Normal file
@@ -0,0 +1,81 @@
|
||||
import os
|
||||
import sys
|
||||
|
||||
import common_compiler_flags
|
||||
|
||||
|
||||
def has_osxcross():
|
||||
return "OSXCROSS_ROOT" in os.environ
|
||||
|
||||
|
||||
def options(opts):
|
||||
opts.Add("macos_deployment_target", "macOS deployment target", "default")
|
||||
opts.Add("macos_sdk_path", "macOS SDK path", "")
|
||||
if has_osxcross():
|
||||
opts.Add("osxcross_sdk", "OSXCross SDK version", "darwin16")
|
||||
|
||||
|
||||
def exists(env):
|
||||
return sys.platform == "darwin" or has_osxcross()
|
||||
|
||||
|
||||
def generate(env):
|
||||
if env["arch"] not in ("universal", "arm64", "x86_64"):
|
||||
print("Only universal, arm64, and x86_64 are supported on macOS. Exiting.")
|
||||
env.Exit(1)
|
||||
|
||||
if sys.platform == "darwin":
|
||||
# Use clang on macOS by default
|
||||
env["CXX"] = "clang++"
|
||||
env["CC"] = "clang"
|
||||
else:
|
||||
# OSXCross
|
||||
root = os.environ.get("OSXCROSS_ROOT", "")
|
||||
if env["arch"] == "arm64":
|
||||
basecmd = root + "/target/bin/arm64-apple-" + env["osxcross_sdk"] + "-"
|
||||
else:
|
||||
basecmd = root + "/target/bin/x86_64-apple-" + env["osxcross_sdk"] + "-"
|
||||
|
||||
env["CC"] = basecmd + "clang"
|
||||
env["CXX"] = basecmd + "clang++"
|
||||
env["AR"] = basecmd + "ar"
|
||||
env["RANLIB"] = basecmd + "ranlib"
|
||||
env["AS"] = basecmd + "as"
|
||||
|
||||
binpath = os.path.join(root, "target", "bin")
|
||||
if binpath not in env["ENV"]["PATH"]:
|
||||
# Add OSXCROSS bin folder to PATH (required for linking).
|
||||
env.PrependENVPath("PATH", binpath)
|
||||
|
||||
# Common flags
|
||||
if env["arch"] == "universal":
|
||||
env.Append(LINKFLAGS=["-arch", "x86_64", "-arch", "arm64"])
|
||||
env.Append(CCFLAGS=["-arch", "x86_64", "-arch", "arm64"])
|
||||
else:
|
||||
env.Append(LINKFLAGS=["-arch", env["arch"]])
|
||||
env.Append(CCFLAGS=["-arch", env["arch"]])
|
||||
|
||||
if env["macos_deployment_target"] != "default":
|
||||
env.Append(CCFLAGS=["-mmacosx-version-min=" + env["macos_deployment_target"]])
|
||||
env.Append(LINKFLAGS=["-mmacosx-version-min=" + env["macos_deployment_target"]])
|
||||
|
||||
if env["macos_sdk_path"]:
|
||||
env.Append(CCFLAGS=["-isysroot", env["macos_sdk_path"]])
|
||||
env.Append(LINKFLAGS=["-isysroot", env["macos_sdk_path"]])
|
||||
|
||||
env.Append(
|
||||
LINKFLAGS=[
|
||||
"-framework",
|
||||
"Cocoa",
|
||||
"-Wl,-undefined,dynamic_lookup",
|
||||
]
|
||||
)
|
||||
|
||||
env.Append(CPPDEFINES=["MACOS_ENABLED", "UNIX_ENABLED"])
|
||||
|
||||
# Refer to https://github.com/godotengine/godot/blob/master/platform/macos/detect.py
|
||||
# LTO benefits for macOS (size, performance) haven't been clearly established yet.
|
||||
if env["lto"] == "auto":
|
||||
env["lto"] = "none"
|
||||
|
||||
common_compiler_flags.generate(env)
|
||||
51
cobor_vm_extension/godot-cpp/tools/my_spawn.py
Normal file
51
cobor_vm_extension/godot-cpp/tools/my_spawn.py
Normal file
@@ -0,0 +1,51 @@
|
||||
import os
|
||||
|
||||
|
||||
def exists(env):
|
||||
return os.name == "nt"
|
||||
|
||||
|
||||
# Workaround for MinGW. See:
|
||||
# http://www.scons.org/wiki/LongCmdLinesOnWin32
|
||||
def configure(env):
|
||||
import subprocess
|
||||
|
||||
def mySubProcess(cmdline, env):
|
||||
# print "SPAWNED : " + cmdline
|
||||
startupinfo = subprocess.STARTUPINFO()
|
||||
startupinfo.dwFlags |= subprocess.STARTF_USESHOWWINDOW
|
||||
proc = subprocess.Popen(
|
||||
cmdline,
|
||||
stdin=subprocess.PIPE,
|
||||
stdout=subprocess.PIPE,
|
||||
stderr=subprocess.PIPE,
|
||||
startupinfo=startupinfo,
|
||||
shell=False,
|
||||
env=env,
|
||||
)
|
||||
data, err = proc.communicate()
|
||||
rv = proc.wait()
|
||||
if rv:
|
||||
print("=====")
|
||||
print(err.decode("utf-8"))
|
||||
print("=====")
|
||||
return rv
|
||||
|
||||
def mySpawn(sh, escape, cmd, args, env):
|
||||
newargs = " ".join(args[1:])
|
||||
cmdline = cmd + " " + newargs
|
||||
|
||||
rv = 0
|
||||
if len(cmdline) > 32000 and cmd.endswith("ar"):
|
||||
cmdline = cmd + " " + args[1] + " " + args[2] + " "
|
||||
for i in range(3, len(args)):
|
||||
rv = mySubProcess(cmdline + args[i], env)
|
||||
if rv:
|
||||
break
|
||||
else:
|
||||
rv = mySubProcess(cmdline, env)
|
||||
|
||||
return rv
|
||||
|
||||
env["SPAWN"] = mySpawn
|
||||
env.Replace(ARFLAGS=["q"])
|
||||
59
cobor_vm_extension/godot-cpp/tools/web.py
Normal file
59
cobor_vm_extension/godot-cpp/tools/web.py
Normal file
@@ -0,0 +1,59 @@
|
||||
import common_compiler_flags
|
||||
from SCons.Util import WhereIs
|
||||
|
||||
|
||||
def exists(env):
|
||||
return WhereIs("emcc") is not None
|
||||
|
||||
|
||||
def generate(env):
|
||||
if env["arch"] not in ("wasm32"):
|
||||
print("Only wasm32 supported on web. Exiting.")
|
||||
env.Exit(1)
|
||||
|
||||
# Emscripten toolchain
|
||||
env["CC"] = "emcc"
|
||||
env["CXX"] = "em++"
|
||||
env["AR"] = "emar"
|
||||
env["RANLIB"] = "emranlib"
|
||||
|
||||
# Use TempFileMunge since some AR invocations are too long for cmd.exe.
|
||||
# Use POSIX-style paths, required with TempFileMunge.
|
||||
env["ARCOM_POSIX"] = env["ARCOM"].replace("$TARGET", "$TARGET.posix").replace("$SOURCES", "$SOURCES.posix")
|
||||
env["ARCOM"] = "${TEMPFILE(ARCOM_POSIX)}"
|
||||
|
||||
# All intermediate files are just object files.
|
||||
env["OBJSUFFIX"] = ".o"
|
||||
env["SHOBJSUFFIX"] = ".o"
|
||||
|
||||
# Static libraries clang-style.
|
||||
env["LIBPREFIX"] = "lib"
|
||||
env["LIBSUFFIX"] = ".a"
|
||||
|
||||
# Shared library as wasm.
|
||||
env["SHLIBSUFFIX"] = ".wasm"
|
||||
|
||||
# Thread support (via SharedArrayBuffer).
|
||||
if env["threads"]:
|
||||
env.Append(CCFLAGS=["-sUSE_PTHREADS=1"])
|
||||
env.Append(LINKFLAGS=["-sUSE_PTHREADS=1"])
|
||||
|
||||
# Build as side module (shared library).
|
||||
env.Append(CCFLAGS=["-sSIDE_MODULE=1"])
|
||||
env.Append(LINKFLAGS=["-sSIDE_MODULE=1"])
|
||||
|
||||
# Enable WebAssembly BigInt <-> i64 conversion.
|
||||
# This must match the flag used to build Godot (true in official builds since 4.3)
|
||||
env.Append(LINKFLAGS=["-sWASM_BIGINT"])
|
||||
|
||||
# Force wasm longjmp mode.
|
||||
env.Append(CCFLAGS=["-sSUPPORT_LONGJMP='wasm'"])
|
||||
env.Append(LINKFLAGS=["-sSUPPORT_LONGJMP='wasm'"])
|
||||
|
||||
env.Append(CPPDEFINES=["WEB_ENABLED", "UNIX_ENABLED"])
|
||||
|
||||
# Refer to https://github.com/godotengine/godot/blob/master/platform/web/detect.py
|
||||
if env["lto"] == "auto":
|
||||
env["lto"] = "full"
|
||||
|
||||
common_compiler_flags.generate(env)
|
||||
214
cobor_vm_extension/godot-cpp/tools/windows.py
Normal file
214
cobor_vm_extension/godot-cpp/tools/windows.py
Normal file
@@ -0,0 +1,214 @@
|
||||
import os
|
||||
import sys
|
||||
|
||||
import common_compiler_flags
|
||||
import my_spawn
|
||||
from SCons.Tool import mingw, msvc
|
||||
from SCons.Variables import BoolVariable
|
||||
|
||||
|
||||
def silence_msvc(env):
|
||||
import os
|
||||
import re
|
||||
import tempfile
|
||||
|
||||
# Ensure we have a location to write captured output to, in case of false positives.
|
||||
capture_path = os.path.join(os.path.dirname(__file__), "..", "msvc_capture.log")
|
||||
with open(capture_path, "wt", encoding="utf-8"):
|
||||
pass
|
||||
|
||||
old_spawn = env["SPAWN"]
|
||||
re_redirect_stream = re.compile(r"^[12]?>")
|
||||
re_cl_capture = re.compile(r"^.+\.(c|cc|cpp|cxx|c[+]{2})$", re.IGNORECASE)
|
||||
re_link_capture = re.compile(r'\s{3}\S.+\s(?:"[^"]+.lib"|\S+.lib)\s.+\s(?:"[^"]+.exp"|\S+.exp)')
|
||||
|
||||
def spawn_capture(sh, escape, cmd, args, env):
|
||||
# We only care about cl/link, process everything else as normal.
|
||||
if args[0] not in ["cl", "link"]:
|
||||
return old_spawn(sh, escape, cmd, args, env)
|
||||
|
||||
# Process as normal if the user is manually rerouting output.
|
||||
for arg in args:
|
||||
if re_redirect_stream.match(arg):
|
||||
return old_spawn(sh, escape, cmd, args, env)
|
||||
|
||||
tmp_stdout, tmp_stdout_name = tempfile.mkstemp()
|
||||
os.close(tmp_stdout)
|
||||
args.append(f">{tmp_stdout_name}")
|
||||
ret = old_spawn(sh, escape, cmd, args, env)
|
||||
|
||||
try:
|
||||
with open(tmp_stdout_name, "r", encoding=sys.stdout.encoding, errors="replace") as tmp_stdout:
|
||||
lines = tmp_stdout.read().splitlines()
|
||||
os.remove(tmp_stdout_name)
|
||||
except OSError:
|
||||
pass
|
||||
|
||||
# Early process no lines (OSError)
|
||||
if not lines:
|
||||
return ret
|
||||
|
||||
is_cl = args[0] == "cl"
|
||||
content = ""
|
||||
caught = False
|
||||
for line in lines:
|
||||
# These conditions are far from all-encompassing, but are specialized
|
||||
# for what can be reasonably expected to show up in the repository.
|
||||
if not caught and (is_cl and re_cl_capture.match(line)) or (not is_cl and re_link_capture.match(line)):
|
||||
caught = True
|
||||
try:
|
||||
with open(capture_path, "a", encoding=sys.stdout.encoding) as log:
|
||||
log.write(line + "\n")
|
||||
except OSError:
|
||||
print(f'WARNING: Failed to log captured line: "{line}".')
|
||||
continue
|
||||
content += line + "\n"
|
||||
# Content remaining assumed to be an error/warning.
|
||||
if content:
|
||||
sys.stderr.write(content)
|
||||
|
||||
return ret
|
||||
|
||||
env["SPAWN"] = spawn_capture
|
||||
|
||||
|
||||
def options(opts):
|
||||
mingw = os.getenv("MINGW_PREFIX", "")
|
||||
|
||||
opts.Add(BoolVariable("use_mingw", "Use the MinGW compiler instead of MSVC - only effective on Windows", False))
|
||||
opts.Add(BoolVariable("use_static_cpp", "Link MinGW/MSVC C++ runtime libraries statically", True))
|
||||
opts.Add(BoolVariable("silence_msvc", "Silence MSVC's cl/link stdout bloat, redirecting errors to stderr.", True))
|
||||
opts.Add(BoolVariable("debug_crt", "Compile with MSVC's debug CRT (/MDd)", False))
|
||||
opts.Add(BoolVariable("use_llvm", "Use the LLVM compiler (MVSC or MinGW depending on the use_mingw flag)", False))
|
||||
opts.Add("mingw_prefix", "MinGW prefix", mingw)
|
||||
|
||||
|
||||
def exists(env):
|
||||
return True
|
||||
|
||||
|
||||
def generate(env):
|
||||
if not env["use_mingw"] and msvc.exists(env):
|
||||
if env["arch"] == "x86_64":
|
||||
env["TARGET_ARCH"] = "amd64"
|
||||
elif env["arch"] == "arm64":
|
||||
env["TARGET_ARCH"] = "arm64"
|
||||
elif env["arch"] == "arm32":
|
||||
env["TARGET_ARCH"] = "arm"
|
||||
elif env["arch"] == "x86_32":
|
||||
env["TARGET_ARCH"] = "x86"
|
||||
|
||||
env["MSVC_SETUP_RUN"] = False # Need to set this to re-run the tool
|
||||
env["MSVS_VERSION"] = None
|
||||
env["MSVC_VERSION"] = None
|
||||
|
||||
env["is_msvc"] = True
|
||||
|
||||
# MSVC, linker, and archiver.
|
||||
msvc.generate(env)
|
||||
env.Tool("msvc")
|
||||
env.Tool("mslib")
|
||||
env.Tool("mslink")
|
||||
|
||||
env.Append(CPPDEFINES=["TYPED_METHOD_BIND", "NOMINMAX"])
|
||||
env.Append(CCFLAGS=["/utf-8"])
|
||||
env.Append(LINKFLAGS=["/WX"])
|
||||
|
||||
if env["use_llvm"]:
|
||||
env["CC"] = "clang-cl"
|
||||
env["CXX"] = "clang-cl"
|
||||
|
||||
if env["debug_crt"]:
|
||||
# Always use dynamic runtime, static debug CRT breaks thread_local.
|
||||
env.AppendUnique(CCFLAGS=["/MDd"])
|
||||
else:
|
||||
if env["use_static_cpp"]:
|
||||
env.AppendUnique(CCFLAGS=["/MT"])
|
||||
else:
|
||||
env.AppendUnique(CCFLAGS=["/MD"])
|
||||
|
||||
if env["silence_msvc"] and not env.GetOption("clean"):
|
||||
silence_msvc(env)
|
||||
|
||||
elif (sys.platform == "win32" or sys.platform == "msys") and not env["mingw_prefix"]:
|
||||
env["use_mingw"] = True
|
||||
mingw.generate(env)
|
||||
# Don't want lib prefixes
|
||||
env["IMPLIBPREFIX"] = ""
|
||||
env["SHLIBPREFIX"] = ""
|
||||
# Want dll suffix
|
||||
env["SHLIBSUFFIX"] = ".dll"
|
||||
|
||||
env.Append(CCFLAGS=["-Wwrite-strings"])
|
||||
env.Append(LINKFLAGS=["-Wl,--no-undefined"])
|
||||
if env["use_static_cpp"]:
|
||||
env.Append(
|
||||
LINKFLAGS=[
|
||||
"-static",
|
||||
"-static-libgcc",
|
||||
"-static-libstdc++",
|
||||
]
|
||||
)
|
||||
|
||||
# Long line hack. Use custom spawn, quick AR append (to avoid files with the same names to override each other).
|
||||
my_spawn.configure(env)
|
||||
|
||||
else:
|
||||
env["use_mingw"] = True
|
||||
# Cross-compilation using MinGW
|
||||
prefix = ""
|
||||
if env["mingw_prefix"]:
|
||||
prefix = env["mingw_prefix"] + "/bin/"
|
||||
|
||||
if env["arch"] == "x86_64":
|
||||
prefix += "x86_64"
|
||||
elif env["arch"] == "arm64":
|
||||
prefix += "aarch64"
|
||||
elif env["arch"] == "arm32":
|
||||
prefix += "armv7"
|
||||
elif env["arch"] == "x86_32":
|
||||
prefix += "i686"
|
||||
|
||||
if env["use_llvm"]:
|
||||
env["CXX"] = prefix + "-w64-mingw32-clang++"
|
||||
env["CC"] = prefix + "-w64-mingw32-clang"
|
||||
env["AR"] = prefix + "-w64-mingw32-llvm-ar"
|
||||
env["RANLIB"] = prefix + "-w64-mingw32-ranlib"
|
||||
env["LINK"] = prefix + "-w64-mingw32-clang"
|
||||
else:
|
||||
env["CXX"] = prefix + "-w64-mingw32-g++"
|
||||
env["CC"] = prefix + "-w64-mingw32-gcc"
|
||||
env["AR"] = prefix + "-w64-mingw32-gcc-ar"
|
||||
env["RANLIB"] = prefix + "-w64-mingw32-ranlib"
|
||||
env["LINK"] = prefix + "-w64-mingw32-g++"
|
||||
|
||||
# Want dll suffix
|
||||
env["SHLIBSUFFIX"] = ".dll"
|
||||
|
||||
env.Append(CCFLAGS=["-Wwrite-strings"])
|
||||
env.Append(LINKFLAGS=["-Wl,--no-undefined"])
|
||||
if env["use_static_cpp"]:
|
||||
env.Append(
|
||||
LINKFLAGS=[
|
||||
"-static",
|
||||
"-static-libgcc",
|
||||
"-static-libstdc++",
|
||||
]
|
||||
)
|
||||
if env["use_llvm"]:
|
||||
env.Append(LINKFLAGS=["-lstdc++"])
|
||||
|
||||
if sys.platform == "win32" or sys.platform == "msys":
|
||||
my_spawn.configure(env)
|
||||
|
||||
env.Append(CPPDEFINES=["WINDOWS_ENABLED"])
|
||||
|
||||
# Refer to https://github.com/godotengine/godot/blob/master/platform/windows/detect.py
|
||||
if env["lto"] == "auto":
|
||||
if env.get("is_msvc", False):
|
||||
# No LTO by default for MSVC, doesn't help.
|
||||
env["lto"] = "none"
|
||||
else: # Release
|
||||
env["lto"] = "full"
|
||||
|
||||
common_compiler_flags.generate(env)
|
||||
Reference in New Issue
Block a user