import methods import os def is_active(): return True def get_name(): return "Windows" def can_build(): if (os.name == "nt"): # Building natively on Windows # If VCINSTALLDIR is set in the OS environ, use traditional Godot logic to set up MSVC if (os.getenv("VCINSTALLDIR")): # MSVC, manual setup return True # Otherwise, let SCons find MSVC if installed, or else Mingw. # Since we're just returning True here, if there's no compiler # installed, we'll get errors when it tries to build with the # null compiler. return True if (os.name == "posix"): # Cross-compiling with MinGW-w64 (old MinGW32 is not supported) mingw32 = "i686-w64-mingw32-" mingw64 = "x86_64-w64-mingw32-" if (os.getenv("MINGW32_PREFIX")): mingw32 = os.getenv("MINGW32_PREFIX") if (os.getenv("MINGW64_PREFIX")): mingw64 = os.getenv("MINGW64_PREFIX") test = "gcc --version > /dev/null 2>&1" if (os.system(mingw64 + test) == 0 or os.system(mingw32 + test) == 0): return True return False def get_opts(): from SCons.Variables import BoolVariable, EnumVariable mingw32 = "" mingw64 = "" if (os.name == "posix"): mingw32 = "i686-w64-mingw32-" mingw64 = "x86_64-w64-mingw32-" if (os.getenv("MINGW32_PREFIX")): mingw32 = os.getenv("MINGW32_PREFIX") if (os.getenv("MINGW64_PREFIX")): mingw64 = os.getenv("MINGW64_PREFIX") return [ ('mingw_prefix_32', 'MinGW prefix (Win32)', mingw32), ('mingw_prefix_64', 'MinGW prefix (Win64)', mingw64), # Targeted Windows version: 7 (and later), minimum supported version # XP support dropped after EOL due to missing API for IPv6 and other issues # Vista support dropped after EOL due to GH-10243 ('target_win_version', 'Targeted Windows version, >= 0x0601 (Windows 7)', '0x0601'), EnumVariable('debug_symbols', 'Add debugging symbols to release builds', 'yes', ('yes', 'no', 'full')), BoolVariable('separate_debug_symbols', 'Create a separate file containing debugging symbols', False), ('msvc_version', 'MSVC version to use. Ignored if VCINSTALLDIR is set in shell env.', None), BoolVariable('use_mingw', 'Use the Mingw compiler, even if MSVC is installed. Only used on Windows.', False), ] def get_flags(): return [ ] def build_res_file(target, source, env): if (env["bits"] == "32"): cmdbase = env['mingw_prefix_32'] else: cmdbase = env['mingw_prefix_64'] cmdbase = cmdbase + 'windres --include-dir . ' import subprocess for x in range(len(source)): cmd = cmdbase + '-i ' + str(source[x]) + ' -o ' + str(target[x]) try: out = subprocess.Popen(cmd, shell=True, stderr=subprocess.PIPE).communicate() if len(out[1]): return 1 except: return 1 return 0 def setup_msvc_manual(env): """Set up env to use MSVC manually, using VCINSTALLDIR""" if (env["bits"] != "default"): print(""" Bits argument is not supported for MSVC compilation. Architecture depends on the Native/Cross Compile Tools Prompt/Developer Console (or Visual Studio settings) that is being used to run SCons. As a consequence, bits argument is disabled. Run scons again without bits argument (example: scons p=windows) and SCons will attempt to detect what MSVC compiler will be executed and inform you. """) raise SCons.Errors.UserError("Bits argument should not be used when using VCINSTALLDIR") # Force bits arg # (Actually msys2 mingw can support 64-bit, we could detect that) env["bits"] = "32" env["x86_libtheora_opt_vc"] = True # find compiler manually compiler_version_str = methods.detect_visual_c_compiler_version(env['ENV']) print("Found MSVC compiler: " + compiler_version_str) # If building for 64bit architecture, disable assembly optimisations for 32 bit builds (theora as of writing)... vc compiler for 64bit can not compile _asm if(compiler_version_str == "amd64" or compiler_version_str == "x86_amd64"): env["bits"] = "64" env["x86_libtheora_opt_vc"] = False print("Compiled program architecture will be a 64 bit executable (forcing bits=64).") elif (compiler_version_str == "x86" or compiler_version_str == "amd64_x86"): print("Compiled program architecture will be a 32 bit executable. (forcing bits=32).") else: print("Failed to manually detect MSVC compiler architecture version... Defaulting to 32bit executable settings (forcing bits=32). Compilation attempt will continue, but SCons can not detect for what architecture this build is compiled for. You should check your settings/compilation setup, or avoid setting VCINSTALLDIR.") def setup_msvc_auto(env): """Set up MSVC using SCons's auto-detection logic""" # If MSVC_VERSION is set by SCons, we know MSVC is installed. # But we may want a different version or target arch. # The env may have already been set up with default MSVC tools, so # reset a few things so we can set it up with the tools we want. # (Ideally we'd decide on the tool config before configuring any # environment, and just set the env up once, but this function runs # on an existing env so this is the simplest way.) env['MSVC_SETUP_RUN'] = False # Need to set this to re-run the tool env['MSVS_VERSION'] = None env['MSVC_VERSION'] = None env['TARGET_ARCH'] = None if env['bits'] != 'default': env['TARGET_ARCH'] = {'32': 'x86', '64': 'x86_64'}[env['bits']] if env.has_key('msvc_version'): env['MSVC_VERSION'] = env['msvc_version'] env.Tool('msvc') env.Tool('mssdk') # we want the MS SDK # Note: actual compiler version can be found in env['MSVC_VERSION'], e.g. "14.1" for VS2015 # Get actual target arch into bits (it may be "default" at this point): if env['TARGET_ARCH'] in ('amd64', 'x86_64'): env['bits'] = '64' else: env['bits'] = '32' print(" Found MSVC version %s, arch %s, bits=%s" % (env['MSVC_VERSION'], env['TARGET_ARCH'], env['bits'])) if env['TARGET_ARCH'] in ('amd64', 'x86_64'): env["x86_libtheora_opt_vc"] = False def setup_mingw(env): """Set up env for use with mingw""" # Nothing to do here print("Using Mingw") pass def configure_msvc(env, manual_msvc_config): """Configure env to work with MSVC""" # Build type if (env["target"] == "release"): if (env["optimize"] == "speed"): #optimize for speed (default) env.Append(CCFLAGS=['/O2']) else: # optimize for size env.Append(CCFLAGS=['/O1']) env.Append(LINKFLAGS=['/SUBSYSTEM:WINDOWS']) env.Append(LINKFLAGS=['/ENTRY:mainCRTStartup']) env.Append(LINKFLAGS=['/OPT:REF']) elif (env["target"] == "release_debug"): if (env["optimize"] == "speed"): #optimize for speed (default) env.Append(CCFLAGS=['/O2']) else: # optimize for size env.Append(CCFLAGS=['/O1']) env.AppendUnique(CPPDEFINES = ['DEBUG_ENABLED']) env.Append(LINKFLAGS=['/SUBSYSTEM:CONSOLE']) env.Append(LINKFLAGS=['/OPT:REF']) elif (env["target"] == "debug"): env.AppendUnique(CCFLAGS=['/Z7', '/Od', '/EHsc']) env.AppendUnique(CPPDEFINES = ['DEBUG_ENABLED', 'DEBUG_MEMORY_ENABLED', 'D3D_DEBUG_INFO']) env.Append(LINKFLAGS=['/SUBSYSTEM:CONSOLE']) env.Append(LINKFLAGS=['/DEBUG']) if (env["debug_symbols"] == "full" or env["debug_symbols"] == "yes"): env.AppendUnique(CCFLAGS=['/Z7']) env.AppendUnique(LINKFLAGS=['/DEBUG']) ## Compile/link flags env.AppendUnique(CCFLAGS=['/MT', '/Gd', '/GR', '/nologo']) env.AppendUnique(CXXFLAGS=['/TP']) # assume all sources are C++ if manual_msvc_config: # should be automatic if SCons found it if os.getenv("WindowsSdkDir") is not None: env.Append(CPPPATH=[os.getenv("WindowsSdkDir") + "/Include"]) else: print("Missing environment variable: WindowsSdkDir") env.AppendUnique(CPPDEFINES = ['WINDOWS_ENABLED', 'OPENGL_ENABLED', 'WASAPI_ENABLED', 'WINMIDI_ENABLED', 'TYPED_METHOD_BIND', 'WIN32', 'MSVC', 'WINVER=%s' % env["target_win_version"], '_WIN32_WINNT=%s' % env["target_win_version"]]) env.AppendUnique(CPPDEFINES=['NOMINMAX']) # disable bogus min/max WinDef.h macros if env["bits"] == "64": env.AppendUnique(CPPDEFINES=['_WIN64']) ## Libs LIBS = ['winmm', 'opengl32', 'dsound', 'kernel32', 'ole32', 'oleaut32', 'user32', 'gdi32', 'IPHLPAPI', 'Shlwapi', 'wsock32', 'Ws2_32', 'shell32', 'advapi32', 'dinput8', 'dxguid', 'imm32', 'bcrypt','Avrt'] env.Append(LINKFLAGS=[p + env["LIBSUFFIX"] for p in LIBS]) if manual_msvc_config: if os.getenv("WindowsSdkDir") is not None: env.Append(LIBPATH=[os.getenv("WindowsSdkDir") + "/Lib"]) else: print("Missing environment variable: WindowsSdkDir") ## LTO if (env["use_lto"]): env.AppendUnique(CCFLAGS=['/GL']) env.AppendUnique(ARFLAGS=['/LTCG']) if env["progress"]: env.AppendUnique(LINKFLAGS=['/LTCG:STATUS']) else: env.AppendUnique(LINKFLAGS=['/LTCG']) if manual_msvc_config: env.Append(CPPPATH=[p for p in os.getenv("INCLUDE").split(";")]) env.Append(LIBPATH=[p for p in os.getenv("LIB").split(";")]) # Incremental linking fix env['BUILDERS']['ProgramOriginal'] = env['BUILDERS']['Program'] env['BUILDERS']['Program'] = methods.precious_program def configure_mingw(env): # Workaround for MinGW. See: # http://www.scons.org/wiki/LongCmdLinesOnWin32 env.use_windows_spawn_fix() ## Build type if (env["target"] == "release"): env.Append(CCFLAGS=['-msse2']) if (env["optimize"] == "speed"): #optimize for speed (default) if (env["bits"] == "64"): env.Append(CCFLAGS=['-O3']) else: env.Append(CCFLAGS=['-O2']) else: #optimize for size env.Prepend(CCFLAGS=['-Os']) env.Append(LINKFLAGS=['-Wl,--subsystem,windows']) if (env["debug_symbols"] == "yes"): env.Prepend(CCFLAGS=['-g1']) if (env["debug_symbols"] == "full"): env.Prepend(CCFLAGS=['-g2']) elif (env["target"] == "release_debug"): env.Append(CCFLAGS=['-O2', '-DDEBUG_ENABLED']) if (env["debug_symbols"] == "yes"): env.Prepend(CCFLAGS=['-g1']) if (env["debug_symbols"] == "full"): env.Prepend(CCFLAGS=['-g2']) if (env["optimize"] == "speed"): #optimize for speed (default) env.Append(CCFLAGS=['-O2']) else: #optimize for size env.Prepend(CCFLAGS=['-Os']) elif (env["target"] == "debug"): env.Append(CCFLAGS=['-g3', '-DDEBUG_ENABLED', '-DDEBUG_MEMORY_ENABLED']) ## Compiler configuration if (os.name == "nt"): env['ENV']['TMP'] = os.environ['TMP'] # way to go scons, you can be so stupid sometimes else: env["PROGSUFFIX"] = env["PROGSUFFIX"] + ".exe" # for linux cross-compilation if (env["bits"] == "default"): if (os.name == "nt"): env["bits"] = "64" if "PROGRAMFILES(X86)" in os.environ else "32" else: # default to 64-bit on Linux env["bits"] = "64" mingw_prefix = "" if (env["bits"] == "32"): env.Append(LINKFLAGS=['-static']) env.Append(LINKFLAGS=['-static-libgcc']) env.Append(LINKFLAGS=['-static-libstdc++']) mingw_prefix = env["mingw_prefix_32"] else: env.Append(LINKFLAGS=['-static']) mingw_prefix = env["mingw_prefix_64"] env["CC"] = mingw_prefix + "gcc" env['AS'] = mingw_prefix + "as" env['CXX'] = mingw_prefix + "g++" env['AR'] = mingw_prefix + "gcc-ar" env['RANLIB'] = mingw_prefix + "gcc-ranlib" env['LINK'] = mingw_prefix + "g++" env["x86_libtheora_opt_gcc"] = True if env['use_lto']: env.Append(CCFLAGS=['-flto']) env.Append(LINKFLAGS=['-flto=' + str(env.GetOption("num_jobs"))]) ## Compile flags env.Append(CCFLAGS=['-DWINDOWS_ENABLED', '-mwindows']) env.Append(CCFLAGS=['-DOPENGL_ENABLED']) env.Append(CCFLAGS=['-DWASAPI_ENABLED']) env.Append(CCFLAGS=['-DWINMIDI_ENABLED']) env.Append(CCFLAGS=['-DWINVER=%s' % env['target_win_version'], '-D_WIN32_WINNT=%s' % env['target_win_version']]) env.Append(LIBS=['mingw32', 'opengl32', 'dsound', 'ole32', 'd3d9', 'winmm', 'gdi32', 'iphlpapi', 'shlwapi', 'wsock32', 'ws2_32', 'kernel32', 'oleaut32', 'dinput8', 'dxguid', 'ksuser', 'imm32', 'bcrypt','avrt']) env.Append(CPPFLAGS=['-DMINGW_ENABLED']) # resrc env.Append(BUILDERS={'RES': env.Builder(action=build_res_file, suffix='.o', src_suffix='.rc')}) def configure(env): # At this point the env has been set up with basic tools/compilers. env.Append(CPPPATH=['#platform/windows']) print("Configuring for Windows: target=%s, bits=%s" % (env['target'], env['bits'])) if (os.name == "nt"): env['ENV'] = os.environ # this makes build less repeatable, but simplifies some things env['ENV']['TMP'] = os.environ['TMP'] # First figure out which compiler, version, and target arch we're using if os.getenv("VCINSTALLDIR") and not env["use_mingw"]: # Manual setup of MSVC setup_msvc_manual(env) env.msvc = True manual_msvc_config = True elif env.get('MSVC_VERSION', '') and not env["use_mingw"]: setup_msvc_auto(env) env.msvc = True manual_msvc_config = False else: setup_mingw(env) env.msvc = False # Now set compiler/linker flags if env.msvc: configure_msvc(env, manual_msvc_config) else: # MinGW configure_mingw(env)