c2a669a9f0
Many contributors (me included) did not fully understand what CCFLAGS, CXXFLAGS and CPPFLAGS refer to exactly, and were thus not using them in the way they are intended to be. As per the SCons manual: https://www.scons.org/doc/HTML/scons-user/apa.html - CCFLAGS: General options that are passed to the C and C++ compilers. - CFLAGS: General options that are passed to the C compiler (C only; not C++). - CXXFLAGS: General options that are passed to the C++ compiler. By default, this includes the value of $CCFLAGS, so that setting $CCFLAGS affects both C and C++ compilation. - CPPFLAGS: User-specified C preprocessor options. These will be included in any command that uses the C preprocessor, including not just compilation of C and C++ source files [...], but also [...] Fortran [...] and [...] assembly language source file[s]. TL;DR: Compiler options go to CCFLAGS, unless they must be restricted to either C (CFLAGS) or C++ (CXXFLAGS). Preprocessor defines go to CPPFLAGS.
617 lines
24 KiB
Python
617 lines
24 KiB
Python
import os
|
|
import os.path
|
|
import sys
|
|
import re
|
|
import glob
|
|
import string
|
|
import subprocess
|
|
from compat import iteritems, isbasestring, decode_utf8
|
|
|
|
|
|
def add_source_files(self, sources, filetype, lib_env=None, shared=False):
|
|
|
|
if isbasestring(filetype):
|
|
dir_path = self.Dir('.').abspath
|
|
filetype = sorted(glob.glob(dir_path + "/" + filetype))
|
|
|
|
for path in filetype:
|
|
sources.append(self.Object(path))
|
|
|
|
|
|
def disable_warnings(self):
|
|
# '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(CPPFLAGS=['/w'])
|
|
self['CCFLAGS'] = [x for x in self['CCFLAGS'] if not x in warn_flags]
|
|
self['CFLAGS'] = [x for x in self['CFLAGS'] if not x in warn_flags]
|
|
self['CXXFLAGS'] = [x for x in self['CXXFLAGS'] if not x in warn_flags]
|
|
else:
|
|
self.Append(CCFLAGS=['-w'])
|
|
self.Append(CFLAGS=['-w'])
|
|
self.Append(CXXFLAGS=['-w'])
|
|
|
|
|
|
def add_module_version_string(self,s):
|
|
self.module_version_string += "." + s
|
|
|
|
|
|
def update_version(module_version_string=""):
|
|
|
|
build_name = "custom_build"
|
|
if os.getenv("BUILD_NAME") != None:
|
|
build_name = 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("#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")
|
|
if hasattr(version, 'patch'):
|
|
f.write("#define VERSION_PATCH " + str(version.patch) + "\n")
|
|
f.write("#define VERSION_STATUS \"" + str(version.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.close()
|
|
|
|
# NOTE: It is safe to generate this file here, since this is still executed serially
|
|
fhash = open("core/version_hash.gen.h", "w")
|
|
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").readline().strip()
|
|
if head.startswith("ref: "):
|
|
head = os.path.join(gitfolder, head[5:])
|
|
if os.path.isfile(head):
|
|
githash = open(head, "r").readline().strip()
|
|
else:
|
|
githash = head
|
|
|
|
fhash.write("#define VERSION_HASH \"" + githash + "\"")
|
|
fhash.close()
|
|
|
|
|
|
def parse_cg_file(fname, uniforms, sizes, conditionals):
|
|
|
|
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()
|
|
|
|
fs.close()
|
|
|
|
|
|
def detect_modules():
|
|
|
|
module_list = []
|
|
includes_cpp = ""
|
|
register_cpp = ""
|
|
unregister_cpp = ""
|
|
|
|
files = glob.glob("modules/*")
|
|
files.sort() # so register_module_types does not change that often, and also plugins are registered in alphabetic order
|
|
for x in files:
|
|
if not os.path.isdir(x):
|
|
continue
|
|
if not os.path.exists(x + "/config.py"):
|
|
continue
|
|
x = x.replace("modules/", "") # rest of world
|
|
x = x.replace("modules\\", "") # win32
|
|
module_list.append(x)
|
|
try:
|
|
with open("modules/" + x + "/register_types.h"):
|
|
includes_cpp += '#include "modules/' + x + '/register_types.h"\n'
|
|
register_cpp += '#ifdef MODULE_' + x.upper() + '_ENABLED\n'
|
|
register_cpp += '\tregister_' + x + '_types();\n'
|
|
register_cpp += '#endif\n'
|
|
unregister_cpp += '#ifdef MODULE_' + x.upper() + '_ENABLED\n'
|
|
unregister_cpp += '\tunregister_' + x + '_types();\n'
|
|
unregister_cpp += '#endif\n'
|
|
except IOError:
|
|
pass
|
|
|
|
modules_cpp = """
|
|
// modules.cpp - THIS FILE IS GENERATED, DO NOT EDIT!!!!!!!
|
|
#include "register_module_types.h"
|
|
|
|
""" + includes_cpp + """
|
|
|
|
void register_module_types() {
|
|
""" + register_cpp + """
|
|
}
|
|
|
|
void unregister_module_types() {
|
|
""" + unregister_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:
|
|
f.write(modules_cpp)
|
|
|
|
return module_list
|
|
|
|
|
|
def win32_spawn(sh, escape, cmd, args, env):
|
|
import subprocess
|
|
newargs = ' '.join(args[1:])
|
|
cmdline = cmd + " " + newargs
|
|
startupinfo = subprocess.STARTUPINFO()
|
|
for e in env:
|
|
if type(env[e]) != type(""):
|
|
env[e] = str(env[e])
|
|
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)
|
|
print("=====")
|
|
return rv
|
|
|
|
"""
|
|
def win32_spawn(sh, escape, cmd, args, spawnenv):
|
|
import win32file
|
|
import win32event
|
|
import win32process
|
|
import win32security
|
|
for var in spawnenv:
|
|
spawnenv[var] = spawnenv[var].encode('ascii', 'replace')
|
|
|
|
sAttrs = win32security.SECURITY_ATTRIBUTES()
|
|
StartupInfo = win32process.STARTUPINFO()
|
|
newargs = ' '.join(map(escape, args[1:]))
|
|
cmdline = cmd + " " + newargs
|
|
|
|
# check for any special operating system commands
|
|
if cmd == 'del':
|
|
for arg in args[1:]:
|
|
win32file.DeleteFile(arg)
|
|
exit_code = 0
|
|
else:
|
|
# otherwise execute the command.
|
|
hProcess, hThread, dwPid, dwTid = win32process.CreateProcess(None, cmdline, None, None, 1, 0, spawnenv, None, StartupInfo)
|
|
win32event.WaitForSingleObject(hProcess, win32event.INFINITE)
|
|
exit_code = win32process.GetExitCodeProcess(hProcess)
|
|
win32file.CloseHandle(hProcess);
|
|
win32file.CloseHandle(hThread);
|
|
return exit_code
|
|
"""
|
|
|
|
def disable_module(self):
|
|
self.disabled_modules.append(self.current_module)
|
|
|
|
def use_windows_spawn_fix(self, platform=None):
|
|
|
|
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 looses 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)
|
|
data, 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 iteritems(env)}
|
|
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
|
|
|
|
self['SPAWN'] = mySpawn
|
|
|
|
|
|
def split_lib(self, libname, src_list = None, env_lib = None):
|
|
env = self
|
|
|
|
num = 0
|
|
cur_base = ""
|
|
max_src = 64
|
|
list = []
|
|
lib_list = []
|
|
|
|
if src_list is None:
|
|
src_list = getattr(env, libname + "_sources")
|
|
|
|
if type(env_lib) == type(None):
|
|
env_lib = env
|
|
|
|
for f in src_list:
|
|
fname = ""
|
|
if type(f) == type(""):
|
|
fname = env.File(f).path
|
|
else:
|
|
fname = env.File(f)[0].path
|
|
fname = fname.replace("\\", "/")
|
|
base = string.join(fname.split("/")[:2], "/")
|
|
if base != cur_base and len(list) > max_src:
|
|
if num > 0:
|
|
lib = env_lib.add_library(libname + str(num), list)
|
|
lib_list.append(lib)
|
|
list = []
|
|
num = num + 1
|
|
cur_base = base
|
|
list.append(f)
|
|
|
|
lib = env_lib.add_library(libname + str(num), list)
|
|
lib_list.append(lib)
|
|
|
|
if len(lib_list) > 0:
|
|
if os.name == 'posix' and sys.platform == 'msys':
|
|
env.Replace(ARFLAGS=['rcsT'])
|
|
lib = env_lib.add_library(libname + "_collated", lib_list)
|
|
lib_list = [lib]
|
|
|
|
lib_base = []
|
|
env_lib.add_source_files(lib_base, "*.cpp")
|
|
lib = env_lib.add_library(libname, lib_base)
|
|
lib_list.insert(0, lib)
|
|
|
|
env.Prepend(LIBS=lib_list)
|
|
|
|
|
|
def save_active_platforms(apnames, ap):
|
|
|
|
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:
|
|
pngw.write(str)
|
|
|
|
|
|
def no_verbose(sys, env):
|
|
|
|
colors = {}
|
|
|
|
# Colors are disabled in non-TTY environments such as pipes. This means
|
|
# that if output is redirected to a file, it will not contain color codes
|
|
if sys.stdout.isatty():
|
|
colors['cyan'] = '\033[96m'
|
|
colors['purple'] = '\033[95m'
|
|
colors['blue'] = '\033[94m'
|
|
colors['green'] = '\033[92m'
|
|
colors['yellow'] = '\033[93m'
|
|
colors['red'] = '\033[91m'
|
|
colors['end'] = '\033[0m'
|
|
else:
|
|
colors['cyan'] = ''
|
|
colors['purple'] = ''
|
|
colors['blue'] = ''
|
|
colors['green'] = ''
|
|
colors['yellow'] = ''
|
|
colors['red'] = ''
|
|
colors['end'] = ''
|
|
|
|
compile_source_message = '%sCompiling %s==> %s$SOURCE%s' % (colors['blue'], colors['purple'], colors['yellow'], colors['end'])
|
|
java_compile_source_message = '%sCompiling %s==> %s$SOURCE%s' % (colors['blue'], colors['purple'], colors['yellow'], colors['end'])
|
|
compile_shared_source_message = '%sCompiling shared %s==> %s$SOURCE%s' % (colors['blue'], colors['purple'], colors['yellow'], colors['end'])
|
|
link_program_message = '%sLinking Program %s==> %s$TARGET%s' % (colors['red'], colors['purple'], colors['yellow'], colors['end'])
|
|
link_library_message = '%sLinking Static Library %s==> %s$TARGET%s' % (colors['red'], colors['purple'], colors['yellow'], colors['end'])
|
|
ranlib_library_message = '%sRanlib Library %s==> %s$TARGET%s' % (colors['red'], colors['purple'], colors['yellow'], colors['end'])
|
|
link_shared_library_message = '%sLinking Shared Library %s==> %s$TARGET%s' % (colors['red'], colors['purple'], colors['yellow'], colors['end'])
|
|
java_library_message = '%sCreating Java Archive %s==> %s$TARGET%s' % (colors['red'], colors['purple'], colors['yellow'], colors['end'])
|
|
|
|
env.Append(CXXCOMSTR=[compile_source_message])
|
|
env.Append(CCCOMSTR=[compile_source_message])
|
|
env.Append(SHCCCOMSTR=[compile_shared_source_message])
|
|
env.Append(SHCXXCOMSTR=[compile_shared_source_message])
|
|
env.Append(ARCOMSTR=[link_library_message])
|
|
env.Append(RANLIBCOMSTR=[ranlib_library_message])
|
|
env.Append(SHLINKCOMSTR=[link_shared_library_message])
|
|
env.Append(LINKCOMSTR=[link_program_message])
|
|
env.Append(JARCOMSTR=[java_library_message])
|
|
env.Append(JAVACCOMSTR=[java_compile_source_message])
|
|
|
|
|
|
def detect_visual_c_compiler_version(tools_env):
|
|
# 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, ie 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"
|
|
|
|
return vc_chosen_compiler_str
|
|
|
|
def find_visual_c_batch_file(env):
|
|
from SCons.Tool.MSCommon.vc import get_default_version, get_host_target, find_batch_file
|
|
|
|
version = get_default_version(env)
|
|
(host_platform, target_platform,req_target_platform) = get_host_target(env)
|
|
return find_batch_file(env, version, host_platform, target_platform)[0]
|
|
|
|
def generate_cpp_hint_file(filename):
|
|
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 IOError:
|
|
print("Could not write cpp.hint file.")
|
|
|
|
def generate_vs_project(env, num_jobs):
|
|
batch_file = find_visual_c_batch_file(env)
|
|
if batch_file:
|
|
def build_commandline(commands):
|
|
common_build_prefix = ['cmd /V /C set "plat=$(PlatformTarget)"',
|
|
'(if "$(PlatformTarget)"=="x64" (set "plat=x86_amd64"))',
|
|
'set "tools=yes"',
|
|
'(if "$(Configuration)"=="release" (set "tools=no"))',
|
|
'call "' + batch_file + '" !plat!']
|
|
|
|
result = " ^& ".join(common_build_prefix + [commands])
|
|
return result
|
|
|
|
env.AddToVSProject(env.core_sources)
|
|
env.AddToVSProject(env.main_sources)
|
|
env.AddToVSProject(env.modules_sources)
|
|
env.AddToVSProject(env.scene_sources)
|
|
env.AddToVSProject(env.servers_sources)
|
|
env.AddToVSProject(env.editor_sources)
|
|
|
|
# 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
|
|
env['MSVSBUILDCOM'] = build_commandline('scons --directory="$(ProjectDir.TrimEnd(\'\\\'))" platform=windows progress=no target=$(Configuration) tools=!tools! -j' + str(num_jobs))
|
|
env['MSVSREBUILDCOM'] = build_commandline('scons --directory="$(ProjectDir.TrimEnd(\'\\\'))" platform=windows progress=no target=$(Configuration) tools=!tools! vsproj=yes -j' + str(num_jobs))
|
|
env['MSVSCLEANCOM'] = build_commandline('scons --directory="$(ProjectDir.TrimEnd(\'\\\'))" --clean platform=windows progress=no target=$(Configuration) tools=!tools! -j' + str(num_jobs))
|
|
|
|
# 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.
|
|
debug_variants = ['debug|Win32'] + ['debug|x64']
|
|
release_variants = ['release|Win32'] + ['release|x64']
|
|
release_debug_variants = ['release_debug|Win32'] + ['release_debug|x64']
|
|
variants = debug_variants + release_variants + release_debug_variants
|
|
debug_targets = ['bin\\godot.windows.tools.32.exe'] + ['bin\\godot.windows.tools.64.exe']
|
|
release_targets = ['bin\\godot.windows.opt.32.exe'] + ['bin\\godot.windows.opt.64.exe']
|
|
release_debug_targets = ['bin\\godot.windows.opt.tools.32.exe'] + ['bin\\godot.windows.opt.tools.64.exe']
|
|
targets = debug_targets + release_targets + release_debug_targets
|
|
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,
|
|
runfile=targets,
|
|
buildtarget=targets,
|
|
auto_build_solution=1,
|
|
variant=variants)
|
|
else:
|
|
print("Could not locate Visual Studio batch file for setting up the build environment. Not generating VS project.")
|
|
|
|
def precious_program(env, program, sources, **args):
|
|
program = env.ProgramOriginal(program, sources, **args)
|
|
env.Precious(program)
|
|
return program
|
|
|
|
def add_shared_library(env, name, sources, **args):
|
|
library = env.SharedLibrary(name, sources, **args)
|
|
env.NoCache(library)
|
|
return library
|
|
|
|
def add_library(env, name, sources, **args):
|
|
library = env.Library(name, sources, **args)
|
|
env.NoCache(library)
|
|
return library
|
|
|
|
def add_program(env, name, sources, **args):
|
|
program = env.Program(name, sources, **args)
|
|
env.NoCache(program)
|
|
return program
|
|
|
|
def CommandNoCache(env, target, sources, command, **args):
|
|
result = env.Command(target, sources, command, **args)
|
|
env.NoCache(result)
|
|
return result
|
|
|
|
def detect_darwin_sdk_path(platform, env):
|
|
sdk_name = ''
|
|
if platform == 'osx':
|
|
sdk_name = 'macosx'
|
|
var_name = 'MACOS_SDK_PATH'
|
|
elif platform == 'iphone':
|
|
sdk_name = 'iphoneos'
|
|
var_name = 'IPHONESDK'
|
|
elif platform == 'iphonesimulator':
|
|
sdk_name = 'iphonesimulator'
|
|
var_name = 'IPHONESDK'
|
|
else:
|
|
raise Exception("Invalid platform argument passed to detect_darwin_sdk_path")
|
|
|
|
if not env[var_name]:
|
|
try:
|
|
sdk_path = decode_utf8(subprocess.check_output(['xcrun', '--sdk', sdk_name, '--show-sdk-path']).strip())
|
|
if sdk_path:
|
|
env[var_name] = sdk_path
|
|
except (subprocess.CalledProcessError, OSError) as e:
|
|
print("Failed to find SDK path while running xcrun --sdk {} --show-sdk-path.".format(sdk_name))
|
|
raise
|
|
|
|
def get_compiler_version(env):
|
|
version = decode_utf8(subprocess.check_output([env['CXX'], '--version']).strip())
|
|
match = re.search('[0-9][0-9.]*', version)
|
|
if match is not None:
|
|
return match.group().split('.')
|
|
else:
|
|
return None
|
|
|
|
def using_gcc(env):
|
|
return 'gcc' in os.path.basename(env["CC"])
|
|
|
|
def using_clang(env):
|
|
return 'clang' in os.path.basename(env["CC"])
|