# Convert string to list of absolute paths (including expanding wildcard)

if isinstance(files, (str, bytes)):

# Keep SCons project-absolute path as they are (no wildcard support)

if files.startswith("#"):

if "*" in files:

print("ERROR: Wildcards can't be expanded in SCons project-absolute path: '{}'".format(files))

return

files = [files]

else:

# Exclude .gen.cpp files from globbing, to avoid including obsolete ones.

# They should instead be added manually.

skip_gen_cpp = "*" in files

dir_path = self.Dir(".").abspath

files = sorted(glob.glob(dir_path + "/" + files))

if skip_gen_cpp:

files = [f for f in files if not f.endswith(".gen.cpp")]

# Add each path as compiled Object following environment (self) configuration

for path in files:

obj = self.Object(path)

if obj in sources:

print('WARNING: Object "{}" already included in environment sources.'.format(obj))

continue

# 'self' is the environment

if self.msvc:

# We have to remove existing warning level defines before appending /w,

# otherwise we get: "warning D9025 : overriding '/W3' with '/w'"

warn_flags = ["/Wall", "/W4", "/W3", "/W2", "/W1", "/WX"]

self.Append(CCFLAGS=["/w"])

self.Append(CFLAGS=["/w"])

self.Append(CXXFLAGS=["/w"])

self["CCFLAGS"] = [x for x in self["CCFLAGS"] if not x in warn_flags]

self["CFLAGS"] = [x for x in self["CFLAGS"] if not x in warn_flags]

self["CXXFLAGS"] = [x for x in self["CXXFLAGS"] if not x in warn_flags]

else:

self.Append(CCFLAGS=["-w"])

self.Append(CFLAGS=["-w"])

# 'self' is the environment

if self["target"] != "debug":

return

if self.msvc:

self.Append(CCFLAGS=["/O2"])

else:

build_name = "custom_build"

if os.getenv("BUILD_NAME") != None:

build_name = str(os.getenv("BUILD_NAME"))

print("Using custom build name: " + build_name)

import version

# NOTE: It is safe to generate this file here, since this is still executed serially

f = open("core/version_generated.gen.h", "w")

f.write("/* THIS FILE IS GENERATED DO NOT EDIT */\n")

f.write("#ifndef VERSION_GENERATED_GEN_H\n")

f.write("#define VERSION_GENERATED_GEN_H\n")

f.write('#define VERSION_SHORT_NAME "' + str(version.short_name) + '"\n')

f.write('#define VERSION_NAME "' + str(version.name) + '"\n')

f.write("#define VERSION_MAJOR " + str(version.major) + "\n")

f.write("#define VERSION_MINOR " + str(version.minor) + "\n")

f.write("#define VERSION_PATCH " + str(version.patch) + "\n")

# For dev snapshots (alpha, beta, RC, etc.) we do not commit status change to Git,

# so this define provides a way to override it without having to modify the source.

godot_status = str(version.status)

if os.getenv("GODOT_VERSION_STATUS") != None:

godot_status = str(os.getenv("GODOT_VERSION_STATUS"))

print("Using version status '{}', overriding the original '{}'.".format(godot_status, str(version.status)))

f.write('#define VERSION_STATUS "' + godot_status + '"\n')

f.write('#define VERSION_BUILD "' + str(build_name) + '"\n')

f.write('#define VERSION_MODULE_CONFIG "' + str(version.module_config) + module_version_string + '"\n')

f.write("#define VERSION_YEAR " + str(version.year) + "\n")

f.write('#define VERSION_WEBSITE "' + str(version.website) + '"\n')

f.write('#define VERSION_DOCS_BRANCH "' + str(version.docs) + '"\n')

f.write('#define VERSION_DOCS_URL "https://docs.godotengine.org/en/" VERSION_DOCS_BRANCH\n')

f.write("#endif // VERSION_GENERATED_GEN_H\n")

f.close()

# NOTE: It is safe to generate this file here, since this is still executed serially

fhash = open("core/version_hash.gen.cpp", "w")

fhash.write("/* THIS FILE IS GENERATED DO NOT EDIT */\n")

fhash.write('#include "core/version.h"\n')

githash = ""

gitfolder = ".git"

if os.path.isfile(".git"):

module_folder = open(".git", "r").readline().strip()

if module_folder.startswith("gitdir: "):

gitfolder = module_folder[8:]

if os.path.isfile(os.path.join(gitfolder, "HEAD")):

head = open(os.path.join(gitfolder, "HEAD"), "r", encoding="utf8").readline().strip()

if head.startswith("ref: "):

ref = head[5:]

head = os.path.join(gitfolder, ref)

packedrefs = os.path.join(gitfolder, "packed-refs")

if os.path.isfile(head):

githash = open(head, "r").readline().strip()

elif os.path.isfile(packedrefs):

# Git may pack refs into a single file. This code searches .git/packed-refs file for the current ref's hash.

# https://mirrors.edge.kernel.org/pub/software/scm/git/docs/git-pack-refs.html

for line in open(packedrefs, "r").read().splitlines():

if line.startswith("#"):

continue

(line_hash, line_ref) = line.split(" ")

if ref == line_ref:

githash = line_hash

break

else:

githash = head

fhash.write('const char *const VERSION_HASH = "' + githash + '";\n')

fs = open(fname, "r")

line = fs.readline()

while line:

if re.match(r"^\s*uniform", line):

res = re.match(r"uniform ([\d\w]*) ([\d\w]*)")

type = res.groups(1)

name = res.groups(2)

uniforms.append(name)

if type.find("texobj") != -1:

sizes.append(1)

else:

t = re.match(r"float(\d)x(\d)", type)

if t:

sizes.append(int(t.groups(1)) * int(t.groups(2)))

else:

t = re.match(r"float(\d)", type)

sizes.append(int(t.groups(1)))

if line.find("[branch]") != -1:

conditionals.append(name)

line = fs.readline()

"""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:

"""Detects and collects a list of C++ modules at specified path

`search_path` - a directory path containing modules. The path may point to

a single module, which may have other nested modules. A module must have

"register_types.h", "SCsub", "config.py" files created to be detected.

`recursive` - if `True`, then all subdirectories are searched for modules as

specified by the `search_path`, otherwise collects all modules under the

`search_path` directory. If the `search_path` is a module, it is collected

in all cases.

Returns an `OrderedDict` with module names as keys, and directory paths as

values. If a path is relative, then it is a built-in module. If a path is

absolute, then it is a custom module collected outside of the engine source.

"""

modules = OrderedDict()

def add_module(path):

module_name = os.path.basename(path)

module_path = path.replace("\\", "/") # win32

modules[module_name] = module_path

def is_engine(path):

# Prevent recursively detecting modules in self and other

# Godot sources when using `custom_modules` build option.

version_path = os.path.join(path, "version.py")

if os.path.exists(version_path):

with open(version_path) as f:

if 'short_name = "godot"' in f.read():

return True

return False

def get_files(path):

files = glob.glob(os.path.join(path, "*"))

# Sort so that `register_module_types` does not change that often,

# and plugins are registered in alphabetic order as well.

files.sort()

return files

if not recursive:

if is_module(search_path):

add_module(search_path)

for path in get_files(search_path):

if is_engine(path):

continue

if is_module(path):

add_module(path)

else:

to_search = [search_path]

while to_search:

path = to_search.pop()

if is_module(path):

add_module(path)

for child in get_files(path):

if not os.path.isdir(child):

continue

if is_engine(child):

continue

to_search.insert(0, child)

if not os.path.isdir(path):

return False

must_exist = ["register_types.h", "SCsub", "config.py"]

for f in must_exist:

if not os.path.exists(os.path.join(path, f)):

return False

f = open("core/disabled_classes.gen.h", "w")

f.write("/* THIS FILE IS GENERATED DO NOT EDIT */\n")

f.write("#ifndef DISABLED_CLASSES_GEN_H\n")

f.write("#define DISABLED_CLASSES_GEN_H\n\n")

for c in class_list:

cs = c.strip()

if cs != "":

f.write("#define ClassDB_Disable_" + cs + " 1\n")

includes_cpp = ""

initialize_cpp = ""

uninitialize_cpp = ""

for name, path in modules.items():

try:

with open(os.path.join(path, "register_types.h")):

includes_cpp += '#include "' + path + '/register_types.h"\n'

initialize_cpp += "#ifdef MODULE_" + name.upper() + "_ENABLED\n"

initialize_cpp += "\tinitialize_" + name + "_module(p_level);\n"

initialize_cpp += "#endif\n"

uninitialize_cpp += "#ifdef MODULE_" + name.upper() + "_ENABLED\n"

uninitialize_cpp += "\tuninitialize_" + name + "_module(p_level);\n"

uninitialize_cpp += "#endif\n"

except OSError:

pass

modules_cpp = """// register_module_types.gen.cpp

/* THIS FILE IS GENERATED DO NOT EDIT */

#include "register_module_types.h"

#include "modules/modules_enabled.gen.h"

%s

void initialize_modules(ModuleInitializationLevel p_level) {

%s

}

void uninitialize_modules(ModuleInitializationLevel p_level) {

%s

}

""" % (

includes_cpp,

initialize_cpp,

uninitialize_cpp,

)

# NOTE: It is safe to generate this file here, since this is still executed serially

with open("modules/register_module_types.gen.cpp", "w") as f:

if not path:

return path

path = os.path.realpath(os.path.expanduser(os.path.expandvars(path)))

err_msg = "Build option 'custom_modules' must %s"

if not os.path.isdir(path):

raise ValueError(err_msg % "point to an existing directory.")

if path == os.path.realpath("modules"):

raise ValueError(err_msg % "be a directory other than built-in `modules` directory.")

"""

Adds dependencies for a given module.

Meant to be used in module `can_build` methods.

"""

if module not in self.module_dependencies:

self.module_dependencies[module] = [[], []]

if optional:

self.module_dependencies[module][1].extend(dependencies)

else:

"""

Checks if module dependencies are enabled for a given module,

and prints a warning if they aren't.

Meant to be used in module `can_build` methods.

Returns a boolean (True if dependencies are satisfied).

"""

missing_deps = []

required_deps = self.module_dependencies[module][0] if module in self.module_dependencies else []

for dep in required_deps:

opt = "module_{}_enabled".format(dep)

if not opt in self or not self[opt]:

missing_deps.append(dep)

if missing_deps != []:

print(

"Disabling '{}' module as the following dependencies are not satisfied: {}".format(

module, ", ".join(missing_deps)

)

)

return False

else:

out = OrderedDict()

deps = {k: v[0] + list(filter(lambda x: x in env.module_list, v[1])) for k, v in env.module_dependencies.items()}

frontier = list(env.module_list.keys())

explored = []

while len(frontier):

cur = frontier.pop()

deps_list = deps[cur] if cur in deps else []

if len(deps_list) and any([d not in explored for d in deps_list]):

# Will explore later, after its dependencies

frontier.insert(0, cur)

continue

explored.append(cur)

for k in explored:

if os.name != "nt":

return # not needed, only for windows

# On Windows, due to the limited command line length, when creating a static library

# from a very high number of objects SCons will invoke "ar" once per object file;

# that makes object files with same names to be overwritten so the last wins and

# the library loses symbols defined by overwritten objects.

# By enabling quick append instead of the default mode (replacing), libraries will

# got built correctly regardless the invocation strategy.

# Furthermore, since SCons will rebuild the library from scratch when an object file

# changes, no multiple versions of the same object file will be present.

self.Replace(ARFLAGS="q")

def mySubProcess(cmdline, env):

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,

text=True,

)

_, err = proc.communicate()

rv = proc.wait()

if rv:

print("=====")

print(err)

print("=====")

return rv

def mySpawn(sh, escape, cmd, args, env):

newargs = " ".join(args[1:])

cmdline = cmd + " " + newargs

rv = 0

env = {str(key): str(value) for key, value in iter(env.items())}

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

for x in ap:

names = ["logo"]

if os.path.isfile(x + "/run_icon.png"):

names.append("run_icon")

for name in names:

pngf = open(x + "/" + name + ".png", "rb")

b = pngf.read(1)

str = " /* AUTOGENERATED FILE, DO NOT EDIT */ \n"

str += " static const unsigned char _" + x[9:] + "_" + name + "[]={"

while len(b) == 1:

str += hex(ord(b))

b = pngf.read(1)

if len(b) == 1:

str += ","

str += "};\n"

pngf.close()

# NOTE: It is safe to generate this file here, since this is still executed serially

wf = x + "/" + name + ".gen.h"

with open(wf, "w") as pngw:

colors = {}

# Colors are disabled in non-TTY environments such as pipes. This means

# that if output is redirected to a file, it will not contain color codes

if sys.stdout.isatty():

colors["blue"] = "\033[0;94m"

colors["bold_blue"] = "\033[1;94m"

colors["reset"] = "\033[0m"

else:

colors["blue"] = ""

colors["bold_blue"] = ""

colors["reset"] = ""

# There is a space before "..." to ensure that source file names can be

# Ctrl + clicked in the VS Code terminal.

compile_source_message = "{}Compiling {}$SOURCE{} ...{}".format(

colors["blue"], colors["bold_blue"], colors["blue"], colors["reset"]

)

java_compile_source_message = "{}Compiling {}$SOURCE{} ...{}".format(

colors["blue"], colors["bold_blue"], colors["blue"], colors["reset"]

)

compile_shared_source_message = "{}Compiling shared {}$SOURCE{} ...{}".format(

colors["blue"], colors["bold_blue"], colors["blue"], colors["reset"]

)

link_program_message = "{}Linking Program {}$TARGET{} ...{}".format(

colors["blue"], colors["bold_blue"], colors["blue"], colors["reset"]

)

link_library_message = "{}Linking Static Library {}$TARGET{} ...{}".format(

colors["blue"], colors["bold_blue"], colors["blue"], colors["reset"]

)

ranlib_library_message = "{}Ranlib Library {}$TARGET{} ...{}".format(

colors["blue"], colors["bold_blue"], colors["blue"], colors["reset"]

)

link_shared_library_message = "{}Linking Shared Library {}$TARGET{} ...{}".format(

colors["blue"], colors["bold_blue"], colors["blue"], colors["reset"]

)

java_library_message = "{}Creating Java Archive {}$TARGET{} ...{}".format(

colors["blue"], colors["bold_blue"], colors["blue"], colors["reset"]

)

env.Append(CXXCOMSTR=[compile_source_message])

env.Append(CCCOMSTR=[compile_source_message])

env.Append(SHCCCOMSTR=[compile_shared_source_message])

env.Append(SHCXXCOMSTR=[compile_shared_source_message])

env.Append(ARCOMSTR=[link_library_message])

env.Append(RANLIBCOMSTR=[ranlib_library_message])

env.Append(SHLINKCOMSTR=[link_shared_library_message])

env.Append(LINKCOMSTR=[link_program_message])

env.Append(JARCOMSTR=[java_library_message])

# tools_env is the variable scons uses to call tools that execute tasks, SCons's env['ENV'] that executes tasks...

# (see the SCons documentation for more information on what it does)...

# in order for this function to be well encapsulated i choose to force it to receive SCons's TOOLS env (env['ENV']

# and not scons setup environment (env)... so make sure you call the right environment on it or it will fail to detect

# the proper vc version that will be called

# There is no flag to give to visual c compilers to set the architecture, i.e. scons bits argument (32,64,ARM etc)

# There are many different cl.exe files that are run, and each one compiles & links to a different architecture

# As far as I know, the only way to figure out what compiler will be run when Scons calls cl.exe via Program()

# is to check the PATH variable and figure out which one will be called first. Code below does that and returns:

# the following string values:

# "" Compiler not detected

# "amd64" Native 64 bit compiler

# "amd64_x86" 64 bit Cross Compiler for 32 bit

# "x86" Native 32 bit compiler

# "x86_amd64" 32 bit Cross Compiler for 64 bit

# There are other architectures, but Godot does not support them currently, so this function does not detect arm/amd64_arm

# and similar architectures/compilers

# Set chosen compiler to "not detected"

vc_chosen_compiler_index = -1

vc_chosen_compiler_str = ""

# Start with Pre VS 2017 checks which uses VCINSTALLDIR:

if "VCINSTALLDIR" in tools_env:

# print("Checking VCINSTALLDIR")

# find() works with -1 so big ifs below are needed... the simplest solution, in fact

# First test if amd64 and amd64_x86 compilers are present in the path

vc_amd64_compiler_detection_index = tools_env["PATH"].find(tools_env["VCINSTALLDIR"] + "BIN\\amd64;")

if vc_amd64_compiler_detection_index > -1:

vc_chosen_compiler_index = vc_amd64_compiler_detection_index

vc_chosen_compiler_str = "amd64"

vc_amd64_x86_compiler_detection_index = tools_env["PATH"].find(tools_env["VCINSTALLDIR"] + "BIN\\amd64_x86;")

if vc_amd64_x86_compiler_detection_index > -1 and (

vc_chosen_compiler_index == -1 or vc_chosen_compiler_index > vc_amd64_x86_compiler_detection_index

):

vc_chosen_compiler_index = vc_amd64_x86_compiler_detection_index

vc_chosen_compiler_str = "amd64_x86"

# Now check the 32 bit compilers

vc_x86_compiler_detection_index = tools_env["PATH"].find(tools_env["VCINSTALLDIR"] + "BIN;")

if vc_x86_compiler_detection_index > -1 and (

vc_chosen_compiler_index == -1 or vc_chosen_compiler_index > vc_x86_compiler_detection_index

):

vc_chosen_compiler_index = vc_x86_compiler_detection_index

vc_chosen_compiler_str = "x86"

vc_x86_amd64_compiler_detection_index = tools_env["PATH"].find(tools_env["VCINSTALLDIR"] + "BIN\\x86_amd64;")

if vc_x86_amd64_compiler_detection_index > -1 and (

vc_chosen_compiler_index == -1 or vc_chosen_compiler_index > vc_x86_amd64_compiler_detection_index

):

vc_chosen_compiler_index = vc_x86_amd64_compiler_detection_index

vc_chosen_compiler_str = "x86_amd64"

# and for VS 2017 and newer we check VCTOOLSINSTALLDIR:

if "VCTOOLSINSTALLDIR" in tools_env:

# Newer versions have a different path available

vc_amd64_compiler_detection_index = (

tools_env["PATH"].upper().find(tools_env["VCTOOLSINSTALLDIR"].upper() + "BIN\\HOSTX64\\X64;")

)

if vc_amd64_compiler_detection_index > -1:

vc_chosen_compiler_index = vc_amd64_compiler_detection_index

vc_chosen_compiler_str = "amd64"

vc_amd64_x86_compiler_detection_index = (

tools_env["PATH"].upper().find(tools_env["VCTOOLSINSTALLDIR"].upper() + "BIN\\HOSTX64\\X86;")

)

if vc_amd64_x86_compiler_detection_index > -1 and (

vc_chosen_compiler_index == -1 or vc_chosen_compiler_index > vc_amd64_x86_compiler_detection_index

):

vc_chosen_compiler_index = vc_amd64_x86_compiler_detection_index

vc_chosen_compiler_str = "amd64_x86"

vc_x86_compiler_detection_index = (

tools_env["PATH"].upper().find(tools_env["VCTOOLSINSTALLDIR"].upper() + "BIN\\HOSTX86\\X86;")

)

if vc_x86_compiler_detection_index > -1 and (

vc_chosen_compiler_index == -1 or vc_chosen_compiler_index > vc_x86_compiler_detection_index

):

vc_chosen_compiler_index = vc_x86_compiler_detection_index

vc_chosen_compiler_str = "x86"

vc_x86_amd64_compiler_detection_index = (

tools_env["PATH"].upper().find(tools_env["VCTOOLSINSTALLDIR"].upper() + "BIN\\HOSTX86\\X64;")

)

if vc_x86_amd64_compiler_detection_index > -1 and (

vc_chosen_compiler_index == -1 or vc_chosen_compiler_index > vc_x86_amd64_compiler_detection_index

):

vc_chosen_compiler_index = vc_x86_amd64_compiler_detection_index

vc_chosen_compiler_str = "x86_amd64"

from SCons.Tool.MSCommon.vc import (

get_default_version,

get_host_target,

find_batch_file,

)

# Syntax changed in SCons 4.4.0.

from SCons import __version__ as scons_raw_version

scons_ver = env._get_major_minor_revision(scons_raw_version)

version = get_default_version(env)

if scons_ver >= (4, 4, 0):

(host_platform, target_platform, _) = get_host_target(env, version)

else:

(host_platform, target_platform, _) = get_host_target(env)

if os.path.isfile(filename):

# Don't overwrite an existing hint file since the user may have customized it.

pass

else:

try:

with open(filename, "w") as fd:

fd.write("#define GDCLASS(m_class, m_inherits)\n")

except OSError:

results = []

for f in Glob(str(node) + "/*", source=True):

if type(f) is Node.FS.Dir:

results += glob_recursive(pattern, f)

results += Glob(str(node) + "/" + pattern, source=True)

for x in sources:

if type(x) == type(""):

fname = env.File(x).path

else:

fname = env.File(x)[0].path

pieces = fname.split(".")

if len(pieces) > 0:

basename = pieces[0]

basename = basename.replace("\\\\", "/")

if os.path.isfile(basename + ".h"):

env.vs_incs += [basename + ".h"]

elif os.path.isfile(basename + ".hpp"):

env.vs_incs += [basename + ".hpp"]

if os.path.isfile(basename + ".c"):

env.vs_srcs += [basename + ".c"]

elif os.path.isfile(basename + ".cpp"):

batch_file = find_visual_c_batch_file(env)

if batch_file:

class ModuleConfigs(Mapping):

# This version information (Win32, x64, Debug, Release, Release_Debug seems to be

# required for Visual Studio to understand that it needs to generate an NMAKE

# project. Do not modify without knowing what you are doing.

PLATFORMS = ["Win32", "x64"]

PLATFORM_IDS = ["32", "64"]

CONFIGURATIONS = ["debug", "release", "release_debug"]

CONFIGURATION_IDS = ["tools", "opt", "opt.tools"]

@staticmethod

def for_every_variant(value):

return [value for _ in range(len(ModuleConfigs.CONFIGURATIONS) * len(ModuleConfigs.PLATFORMS))]

def __init__(self):

shared_targets_array = []

self.names = []

self.arg_dict = {

"variant": [],

"runfile": shared_targets_array,

"buildtarget": shared_targets_array,

"cpppaths": [],

"cppdefines": [],

"cmdargs": [],

}

self.add_mode() # default

def add_mode(

self,

name: str = "",

includes: str = "",

cli_args: str = "",

defines=None,

):

if defines is None:

defines = []

self.names.append(name)

self.arg_dict["variant"] += [

f'{config}{f"_[{name}]" if name else ""}|{platform}'

for config in ModuleConfigs.CONFIGURATIONS

for platform in ModuleConfigs.PLATFORMS

]

self.arg_dict["runfile"] += [

f'bin\\godot.windows.{config_id}.{plat_id}{f".{name}" if name else ""}.exe'

for config_id in ModuleConfigs.CONFIGURATION_IDS

for plat_id in ModuleConfigs.PLATFORM_IDS

]

self.arg_dict["cpppaths"] += ModuleConfigs.for_every_variant(env["CPPPATH"] + [includes])

self.arg_dict["cppdefines"] += ModuleConfigs.for_every_variant(env["CPPDEFINES"] + defines)

self.arg_dict["cmdargs"] += ModuleConfigs.for_every_variant(cli_args)

def build_commandline(self, commands):

configuration_getter = (

"$(Configuration"

+ "".join([f'.Replace("{name}", "")' for name in self.names[1:]])

+ '.Replace("_[]", "")'

+ ")"

)

common_build_prefix = [

'cmd /V /C set "plat=$(PlatformTarget)"',

'(if "$(PlatformTarget)"=="x64" (set "plat=x86_amd64"))',

'set "tools=%s"' % env["tools"],

f'(if "{configuration_getter}"=="release" (set "tools=no"))',

'call "' + batch_file + '" !plat!',

]

# Windows allows us to have spaces in paths, so we need

# to double quote off the directory. However, the path ends

# in a backslash, so we need to remove this, lest it escape the

# last double quote off, confusing MSBuild

common_build_postfix = [

"--directory=\"$(ProjectDir.TrimEnd('\\'))\"",

"platform=windows",

f"target={configuration_getter}",

"progress=no",

"tools=!tools!",

"-j%s" % num_jobs,

]

if env["tests"]:

common_build_postfix.append("tests=yes")

if env["custom_modules"]:

common_build_postfix.append("custom_modules=%s" % env["custom_modules"])

result = " ^& ".join(common_build_prefix + [" ".join([commands] + common_build_postfix)])

return result

# Mappings interface definitions

def __iter__(self) -> Iterator[str]:

for x in self.arg_dict:

yield x

def __len__(self) -> int:

return len(self.names)

def __getitem__(self, k: str):

return self.arg_dict[k]

add_to_vs_project(env, env.core_sources)

add_to_vs_project(env, env.drivers_sources)

add_to_vs_project(env, env.main_sources)

add_to_vs_project(env, env.modules_sources)

add_to_vs_project(env, env.scene_sources)

add_to_vs_project(env, env.servers_sources)

if env["tests"]:

add_to_vs_project(env, env.tests_sources)

add_to_vs_project(env, env.editor_sources)

for header in glob_recursive("**/*.h"):

env.vs_incs.append(str(header))

module_configs = ModuleConfigs()

if env.get("module_mono_enabled"):

import modules.mono.build_scripts.mono_configure as mono_configure

app_host_dir = mono_configure.find_dotnet_app_host_dir(env)

if app_host_dir and os.path.isdir(app_host_dir):

mono_defines = [("NETHOST_USE_AS_STATIC",)]

if env["tools"]:

mono_defines += [("GD_MONO_HOT_RELOAD",)]

module_configs.add_mode(

"mono",

includes=app_host_dir,

cli_args="module_mono_enabled=yes",

defines=mono_defines,

)

else:

print(".NET App Host directory not found. Generated project will not have build variants for .NET.")

env["MSVSBUILDCOM"] = module_configs.build_commandline("scons")

env["MSVSREBUILDCOM"] = module_configs.build_commandline("scons vsproj=yes")

env["MSVSCLEANCOM"] = module_configs.build_commandline("scons --clean")

if not env.get("MSVS"):

env["MSVS"]["PROJECTSUFFIX"] = ".vcxproj"

env["MSVS"]["SOLUTIONSUFFIX"] = ".sln"

env.MSVSProject(

target=["#godot" + env["MSVSPROJECTSUFFIX"]],

incs=env.vs_incs,

srcs=env.vs_srcs,

auto_build_solution=1,

**module_configs,

)

else:

output_print = short_message if not env["verbose"] else ""

if not subprocess:

return Action(function, output_print)

else:

sdk_name = ""

if platform == "macos":

sdk_name = "macosx"

var_name = "MACOS_SDK_PATH"

elif platform == "ios":

sdk_name = "iphoneos"

var_name = "IOS_SDK_PATH"

elif platform == "iossimulator":

sdk_name = "iphonesimulator"

var_name = "IOS_SDK_PATH"

else:

raise Exception("Invalid platform argument passed to detect_darwin_sdk_path")

if not env[var_name]:

try:

sdk_path = subprocess.check_output(["xcrun", "--sdk", sdk_name, "--show-sdk-path"]).strip().decode("utf-8")

if sdk_path:

env[var_name] = sdk_path

except (subprocess.CalledProcessError, OSError):

print("Failed to find SDK path while running xcrun --sdk {} --show-sdk-path.".format(sdk_name))

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

"""

Returns an array of version numbers as ints: [major, minor, patch].

The return array should have at least two values (major, minor).

"""

if not env.msvc:

# Not using -dumpversion as some GCC distros only return major, and

# Clang used to return hardcoded 4.2.1: # https://reviews.llvm.org/D56803

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 None

else: # TODO: Implement for MSVC

return None

match = re.search(

"(?:(?<=version )|(?<=\) )|(?<=^))"

"(?P<major>\d+)"

"(?:\.(?P<minor>\d*))?"

"(?:\.(?P<patch>\d*))?"

"(?:-(?P<metadata1>[0-9a-zA-Z-]*))?"

"(?:\+(?P<metadata2>[0-9a-zA-Z-]*))?"

"(?: (?P<date>[0-9]{8}|[0-9]{6})(?![0-9a-zA-Z]))?",

version,

)

if match is not None:

return match.groupdict()

else:

import sys

from SCons.Script import Progress, Command, AlwaysBuild

screen = sys.stdout

# Progress reporting is not available in non-TTY environments since it

# messes with the output (for example, when writing to a file)

show_progress = env["progress"] and sys.stdout.isatty()

node_count = 0

node_count_max = 0

node_count_interval = 1

node_count_fname = str(env.Dir("#")) + "/.scons_node_count"

import time, math

class cache_progress:

# The default is 1 GB cache and 12 hours half life

def __init__(self, path=None, limit=1073741824, half_life=43200):

self.path = path

self.limit = limit

self.exponent_scale = math.log(2) / half_life

if env["verbose"] and path != None:

screen.write(

"Current cache limit is {} (used: {})\n".format(

self.convert_size(limit), self.convert_size(self.get_size(path))

)

)

self.delete(self.file_list())

def __call__(self, node, *args, **kw):

nonlocal node_count, node_count_max, node_count_interval, node_count_fname, show_progress