d96842b80e
Comment out the weird workaround for building on Windows at it might
not be needed anymore. Testing needed to confirm.
(cherry picked from commit edbc0c0d0b)
403 lines
14 KiB
Python
403 lines
14 KiB
Python
EnsureSConsVersion(0,14);
|
|
|
|
|
|
import string
|
|
import os
|
|
import os.path
|
|
import glob
|
|
import sys
|
|
import methods
|
|
|
|
methods.update_version()
|
|
|
|
# scan possible build platforms
|
|
|
|
platform_list = [] # list of platforms
|
|
platform_opts = {} # options for each platform
|
|
platform_flags = {} # flags for each platform
|
|
|
|
|
|
active_platforms=[]
|
|
active_platform_ids=[]
|
|
platform_exporters=[]
|
|
global_defaults=[]
|
|
|
|
for x in glob.glob("platform/*"):
|
|
if (not os.path.isdir(x) or not os.path.exists(x+"/detect.py")):
|
|
continue
|
|
tmppath="./"+x
|
|
|
|
sys.path.append(tmppath)
|
|
import detect
|
|
|
|
if (os.path.exists(x+"/export/export.cpp")):
|
|
platform_exporters.append(x[9:])
|
|
if (os.path.exists(x+"/globals/global_defaults.cpp")):
|
|
global_defaults.append(x[9:])
|
|
if (detect.is_active()):
|
|
active_platforms.append( detect.get_name() )
|
|
active_platform_ids.append(x);
|
|
if (detect.can_build()):
|
|
x=x.replace("platform/","") # rest of world
|
|
x=x.replace("platform\\","") # win32
|
|
platform_list+=[x]
|
|
platform_opts[x]=detect.get_opts()
|
|
platform_flags[x]=detect.get_flags()
|
|
sys.path.remove(tmppath)
|
|
sys.modules.pop('detect')
|
|
|
|
module_list=methods.detect_modules()
|
|
|
|
|
|
#print "Detected Platforms: "+str(platform_list)
|
|
|
|
methods.save_active_platforms(active_platforms,active_platform_ids)
|
|
|
|
custom_tools=['default']
|
|
|
|
platform_arg = ARGUMENTS.get("platform", ARGUMENTS.get("p", False))
|
|
|
|
if (os.name=="posix"):
|
|
pass
|
|
elif (os.name=="nt"):
|
|
if (os.getenv("VSINSTALLDIR")==None or platform_arg=="android"):
|
|
custom_tools=['mingw']
|
|
|
|
env_base=Environment(tools=custom_tools);
|
|
env_base.AppendENVPath('PATH', os.getenv('PATH'))
|
|
env_base.AppendENVPath('PKG_CONFIG_PATH', os.getenv('PKG_CONFIG_PATH'))
|
|
env_base.global_defaults=global_defaults
|
|
env_base.android_maven_repos=[]
|
|
env_base.android_dependencies=[]
|
|
env_base.android_java_dirs=[]
|
|
env_base.android_res_dirs=[]
|
|
env_base.android_aidl_dirs=[]
|
|
env_base.android_jni_dirs=[]
|
|
env_base.android_default_config=[]
|
|
env_base.android_manifest_chunk=""
|
|
env_base.android_permission_chunk=""
|
|
env_base.android_appattributes_chunk=""
|
|
env_base.disabled_modules=[]
|
|
env_base.use_ptrcall=False
|
|
env_base.split_drivers=False
|
|
|
|
|
|
|
|
env_base.__class__.android_add_maven_repository=methods.android_add_maven_repository
|
|
env_base.__class__.android_add_dependency=methods.android_add_dependency
|
|
env_base.__class__.android_add_java_dir=methods.android_add_java_dir
|
|
env_base.__class__.android_add_res_dir=methods.android_add_res_dir
|
|
env_base.__class__.android_add_aidl_dir=methods.android_add_aidl_dir
|
|
env_base.__class__.android_add_jni_dir=methods.android_add_jni_dir
|
|
env_base.__class__.android_add_default_config=methods.android_add_default_config
|
|
env_base.__class__.android_add_to_manifest = methods.android_add_to_manifest
|
|
env_base.__class__.android_add_to_permissions = methods.android_add_to_permissions
|
|
env_base.__class__.android_add_to_attributes = methods.android_add_to_attributes
|
|
env_base.__class__.disable_module = methods.disable_module
|
|
|
|
env_base.__class__.add_source_files = methods.add_source_files
|
|
env_base.__class__.use_windows_spawn_fix = methods.use_windows_spawn_fix
|
|
|
|
env_base["x86_opt_gcc"]=False
|
|
env_base["x86_opt_vc"]=False
|
|
env_base["armv7_opt_gcc"]=False
|
|
|
|
customs = ['custom.py']
|
|
|
|
profile = ARGUMENTS.get("profile", False)
|
|
if profile:
|
|
import os.path
|
|
if os.path.isfile(profile):
|
|
customs.append(profile)
|
|
elif os.path.isfile(profile+".py"):
|
|
customs.append(profile+".py")
|
|
|
|
opts=Variables(customs, ARGUMENTS)
|
|
opts.Add('target', 'Compile Target (debug/release_debug/release).', "debug")
|
|
opts.Add('arch', 'Platform dependent architecture (arm/arm64/x86/x64/mips/etc)', "")
|
|
opts.Add('bits', 'Compile Target Bits (default/32/64/fat).', "default")
|
|
opts.Add('platform','Platform: '+str(platform_list)+'.',"")
|
|
opts.Add('p','Platform (same as platform=).',"")
|
|
opts.Add('tools','Build Tools (Including Editor): (yes/no)','yes')
|
|
opts.Add('gdscript','Build GDSCript support: (yes/no)','yes')
|
|
opts.Add('libogg','Ogg library for ogg container support (system/builtin)','builtin')
|
|
opts.Add('libvorbis','Ogg Vorbis library for vorbis support (system/builtin)','builtin')
|
|
opts.Add('libtheora','Theora library for theora module (system/builtin)','builtin')
|
|
opts.Add('opus','Opus and opusfile library for Opus format support: (system/builtin)','builtin')
|
|
opts.Add('minizip','Build Minizip Archive Support: (yes/no)','yes')
|
|
opts.Add('squish','Squish library for BC Texture Compression in editor (system/builtin)','builtin')
|
|
opts.Add('freetype','Freetype library for TTF support via freetype module (system/builtin)','builtin')
|
|
# (akien) Unbundling would require work in audio_stream_speex.{cpp,h}, but since speex was
|
|
# removed in 3.0+ and this is only to preserve compatibility in 2.1, I haven't worked on it.
|
|
# Patches welcome if anyone cares :)
|
|
opts.Add('speex','Speex library for speex support','builtin')
|
|
opts.Add('xml','XML Save/Load support (yes/no)','yes')
|
|
opts.Add('libpng','libpng library for image loader support (system/builtin)','builtin')
|
|
opts.Add('libwebp','libwebp library for webp module (system/builtin)','builtin')
|
|
opts.Add('openssl','OpenSSL library for openssl module (system/builtin)','builtin')
|
|
opts.Add('libmpcdec','libmpcdec library for mpc module (system/builtin)','builtin')
|
|
opts.Add('glew','GLEW library for the gl_context (system/builtin)','builtin')
|
|
opts.Add("CXX", "C++ Compiler")
|
|
opts.Add("CC", "C Compiler")
|
|
opts.Add("CCFLAGS", "Custom flags for the C++ compiler");
|
|
opts.Add("CFLAGS", "Custom flags for the C compiler");
|
|
opts.Add("LINKFLAGS", "Custom flags for the linker");
|
|
opts.Add('unix_global_settings_path', 'unix-specific path to system-wide settings. Currently only used by templates.','')
|
|
opts.Add('disable_3d', 'Disable 3D nodes for smaller executable (yes/no)', "no")
|
|
opts.Add('disable_advanced_gui', 'Disable advance 3D gui nodes and behaviors (yes/no)', "no")
|
|
opts.Add('colored', 'Enable colored output for the compilation (yes/no)', 'no')
|
|
opts.Add('deprecated','Enable deprecated features (yes/no)','yes')
|
|
opts.Add('extra_suffix', 'Custom extra suffix added to the base filename of all generated binary files.', '')
|
|
opts.Add('vsproj', 'Generate Visual Studio Project. (yes/no)', 'no')
|
|
|
|
# add platform specific options
|
|
|
|
for k in platform_opts.keys():
|
|
opt_list = platform_opts[k]
|
|
for o in opt_list:
|
|
opts.Add(o[0],o[1],o[2])
|
|
|
|
for x in module_list:
|
|
opts.Add('module_'+x+'_enabled', "Enable module '"+x+"' (yes/no)", "yes")
|
|
|
|
opts.Update(env_base) # update environment
|
|
Help(opts.GenerateHelpText(env_base)) # generate help
|
|
|
|
# add default include paths
|
|
|
|
env_base.Append(CPPPATH=['#core','#core/math','#tools','#drivers','#'])
|
|
|
|
# configure ENV for platform
|
|
env_base.platform_exporters=platform_exporters
|
|
|
|
"""
|
|
sys.path.append("./platform/"+env_base["platform"])
|
|
import detect
|
|
detect.configure(env_base)
|
|
sys.path.remove("./platform/"+env_base["platform"])
|
|
sys.modules.pop('detect')
|
|
"""
|
|
|
|
if (env_base['target']=='debug'):
|
|
env_base.Append(CPPFLAGS=['-DDEBUG_MEMORY_ALLOC']);
|
|
env_base.Append(CPPFLAGS=['-DSCI_NAMESPACE'])
|
|
|
|
if (env_base['deprecated']!='no'):
|
|
env_base.Append(CPPFLAGS=['-DENABLE_DEPRECATED']);
|
|
|
|
env_base.platforms = {}
|
|
|
|
|
|
selected_platform =""
|
|
|
|
if env_base['platform'] != "":
|
|
selected_platform=env_base['platform']
|
|
elif env_base['p'] != "":
|
|
selected_platform=env_base['p']
|
|
env_base["platform"]=selected_platform
|
|
|
|
|
|
|
|
if selected_platform in platform_list:
|
|
|
|
sys.path.append("./platform/"+selected_platform)
|
|
import detect
|
|
if "create" in dir(detect):
|
|
env = detect.create(env_base)
|
|
else:
|
|
env = env_base.Clone()
|
|
|
|
if env['vsproj']=="yes":
|
|
env.vs_incs = []
|
|
env.vs_srcs = []
|
|
|
|
def AddToVSProject( sources ):
|
|
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('\\\\','/')
|
|
env.vs_srcs = env.vs_srcs + [basename + ".cpp"]
|
|
env.vs_incs = env.vs_incs + [basename + ".h"]
|
|
#print basename
|
|
env.AddToVSProject = AddToVSProject
|
|
|
|
env.extra_suffix=""
|
|
|
|
if env["extra_suffix"] != '' :
|
|
env.extra_suffix += '.'+env["extra_suffix"]
|
|
|
|
CCFLAGS = env.get('CCFLAGS', '')
|
|
env['CCFLAGS'] = ''
|
|
|
|
env.Append(CCFLAGS=string.split(str(CCFLAGS)))
|
|
|
|
CFLAGS = env.get('CFLAGS', '')
|
|
env['CFLAGS'] = ''
|
|
|
|
env.Append(CFLAGS=string.split(str(CFLAGS)))
|
|
|
|
LINKFLAGS = env.get('LINKFLAGS', '')
|
|
env['LINKFLAGS'] = ''
|
|
|
|
env.Append(LINKFLAGS=string.split(str(LINKFLAGS)))
|
|
|
|
flag_list = platform_flags[selected_platform]
|
|
for f in flag_list:
|
|
if not (f[0] in ARGUMENTS): # allow command line to override platform flags
|
|
env[f[0]] = f[1]
|
|
|
|
#must happen after the flags, so when flags are used by configure, stuff happens (ie, ssl on x11)
|
|
detect.configure(env)
|
|
|
|
#env['platform_libsuffix'] = env['LIBSUFFIX']
|
|
|
|
suffix="."+selected_platform
|
|
|
|
if (env["target"]=="release"):
|
|
if (env["tools"]=="yes"):
|
|
print("Tools can only be built with targets 'debug' and 'release_debug'.")
|
|
sys.exit(255)
|
|
suffix+=".opt"
|
|
|
|
elif (env["target"]=="release_debug"):
|
|
if (env["tools"]=="yes"):
|
|
suffix+=".opt.tools"
|
|
else:
|
|
suffix+=".opt.debug"
|
|
else:
|
|
if (env["tools"]=="yes"):
|
|
suffix+=".tools"
|
|
else:
|
|
suffix+=".debug"
|
|
|
|
if env["arch"] != "":
|
|
suffix += "."+env["arch"]
|
|
elif (env["bits"]=="32"):
|
|
suffix+=".32"
|
|
elif (env["bits"]=="64"):
|
|
suffix+=".64"
|
|
elif (env["bits"]=="fat"):
|
|
suffix+=".fat"
|
|
|
|
suffix+=env.extra_suffix
|
|
|
|
env["PROGSUFFIX"]=suffix+env["PROGSUFFIX"]
|
|
env["OBJSUFFIX"]=suffix+env["OBJSUFFIX"]
|
|
env["LIBSUFFIX"]=suffix+env["LIBSUFFIX"]
|
|
env["SHLIBSUFFIX"]=suffix+env["SHLIBSUFFIX"]
|
|
|
|
sys.path.remove("./platform/"+selected_platform)
|
|
sys.modules.pop('detect')
|
|
|
|
|
|
env.module_list=[]
|
|
|
|
for x in module_list:
|
|
if env['module_'+x+'_enabled'] != "yes":
|
|
continue
|
|
tmppath="./modules/"+x
|
|
sys.path.append(tmppath)
|
|
env.current_module=x
|
|
import config
|
|
if (config.can_build(selected_platform)):
|
|
config.configure(env)
|
|
env.module_list.append(x)
|
|
sys.path.remove(tmppath)
|
|
sys.modules.pop('config')
|
|
|
|
|
|
if (env.use_ptrcall):
|
|
env.Append(CPPFLAGS=['-DPTRCALL_ENABLED']);
|
|
|
|
# to test 64 bits compiltion
|
|
# env.Append(CPPFLAGS=['-m64'])
|
|
|
|
if (env['tools']=='yes'):
|
|
env.Append(CPPFLAGS=['-DTOOLS_ENABLED'])
|
|
if (env['disable_3d']=='yes'):
|
|
env.Append(CPPFLAGS=['-D_3D_DISABLED'])
|
|
if (env['gdscript']=='yes'):
|
|
env.Append(CPPFLAGS=['-DGDSCRIPT_ENABLED'])
|
|
if (env['disable_advanced_gui']=='yes'):
|
|
env.Append(CPPFLAGS=['-DADVANCED_GUI_DISABLED'])
|
|
|
|
if (env['minizip'] == 'yes'):
|
|
env.Append(CPPFLAGS=['-DMINIZIP_ENABLED'])
|
|
|
|
if (env['xml']=='yes'):
|
|
env.Append(CPPFLAGS=['-DXML_ENABLED'])
|
|
|
|
if (env['colored']=='yes'):
|
|
methods.colored(sys,env)
|
|
|
|
Export('env')
|
|
|
|
#build subdirs, the build order is dependent on link order.
|
|
|
|
SConscript("core/SCsub")
|
|
SConscript("servers/SCsub")
|
|
SConscript("scene/SCsub")
|
|
SConscript("tools/SCsub")
|
|
SConscript("drivers/SCsub")
|
|
SConscript("bin/SCsub")
|
|
|
|
SConscript("modules/SCsub")
|
|
SConscript("main/SCsub")
|
|
|
|
SConscript("platform/"+selected_platform+"/SCsub"); # build selected platform
|
|
|
|
# Microsoft Visual Studio Project Generation
|
|
if (env['vsproj'])=="yes":
|
|
|
|
AddToVSProject(env.core_sources)
|
|
AddToVSProject(env.main_sources)
|
|
AddToVSProject(env.modules_sources)
|
|
AddToVSProject(env.scene_sources)
|
|
AddToVSProject(env.servers_sources)
|
|
AddToVSProject(env.tool_sources)
|
|
|
|
# this env flag won't work, it needs to be set in env_base=Environment(MSVC_VERSION='9.0')
|
|
# Even then, SCons still seems to ignore it and builds with the latest MSVC...
|
|
# That said, it's not needed to be set so far but I'm leaving it here so that this comment
|
|
# has a purpose.
|
|
#env['MSVS_VERSION']='9.0'
|
|
|
|
|
|
# Calls a CMD with /C(lose) and /V(delayed environment variable expansion) options.
|
|
# And runs vcvarsall bat for the propper arhitecture and scons for propper configuration
|
|
env['MSVSBUILDCOM'] = 'cmd /V /C set "plat=$(PlatformTarget)" ^& (if "$(PlatformTarget)"=="x64" (set "plat=x86_amd64")) ^& set "tools=yes" ^& (if "$(Configuration)"=="release" (set "tools=no")) ^& call "$(VCInstallDir)vcvarsall.bat" !plat! ^& scons platform=windows target=$(Configuration) tools=!tools! -j2'
|
|
env['MSVSREBUILDCOM'] = 'cmd /V /C set "plat=$(PlatformTarget)" ^& (if "$(PlatformTarget)"=="x64" (set "plat=x86_amd64")) ^& set "tools=yes" ^& (if "$(Configuration)"=="release" (set "tools=no")) & call "$(VCInstallDir)vcvarsall.bat" !plat! ^& scons platform=windows target=$(Configuration) tools=!tools! vsproj=yes -j2'
|
|
env['MSVSCLEANCOM'] = 'cmd /V /C set "plat=$(PlatformTarget)" ^& (if "$(PlatformTarget)"=="x64" (set "plat=x86_amd64")) ^& set "tools=yes" ^& (if "$(Configuration)"=="release" (set "tools=no")) ^& call "$(VCInstallDir)vcvarsall.bat" !plat! ^& scons --clean platform=windows target=$(Configuration) tools=!tools! -j2'
|
|
|
|
# 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 = ['Debug']+['Debug']
|
|
release_targets = ['Release']+['Release']
|
|
release_debug_targets = ['ReleaseDebug']+['ReleaseDebug']
|
|
targets = debug_targets + release_targets + release_debug_targets
|
|
msvproj = 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("No valid target platform selected.")
|
|
print("The following were detected:")
|
|
for x in platform_list:
|
|
print("\t"+x)
|
|
print("\nPlease run scons again with argument: platform=<string>")
|