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/release_debug builds", "yes", ("yes", "no")),
EnumVariable("windows_subsystem", "Windows subsystem", "default", ("default", "console", "gui")),
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),
BoolVariable("use_llvm", "Use the LLVM compiler", False),
BoolVariable("use_thinlto", "Use ThinLTO", False),
]
def get_opts():
from SCons.Variables import BoolVariable, EnumVariable
return [
("osxcross_sdk", "OSXCross SDK version", "darwin16"),
("MACOS_SDK_PATH", "Path to the macOS SDK", ""),
BoolVariable(
"use_static_mvk",
"Link MoltenVK statically as Level-0 driver (better portability) or use Vulkan ICD loader (enables"
" validation layers)",
False,
),
EnumVariable("macports_clang", "Build using Clang from MacPorts", "no",
("no", "5.0", "devel")),
EnumVariable("debug_symbols",
"Add debugging symbols to release/release_debug builds",
"yes", ("yes", "no")),
BoolVariable("separate_debug_symbols",
"Create a separate file containing debugging symbols",
False),
BoolVariable(
"use_ubsan",
"Use LLVM/GCC compiler undefined behavior sanitizer (UBSAN)",
False),
BoolVariable("use_asan",
"Use LLVM/GCC compiler address sanitizer (ASAN))", False),
BoolVariable("use_tsan",
"Use LLVM/GCC compiler thread sanitizer (TSAN))", False),
]
def options(opts):
opts.AddVariables(
EnumVariable('PACKAGETYPE',
'the type of package to create.',
None,
allowed_values=list(map(str, __all__)),
ignorecase=2))
def get_opts():
from SCons.Variables import EnumVariable
return [
EnumVariable('debug_symbols', 'Add debug symbols to release version',
'yes', ('yes', 'no', 'full')),
]
def get_opts():
from SCons.Variables import BoolVariable, EnumVariable
return [
BoolVariable('use_llvm', 'Use the LLVM compiler', False),
BoolVariable('use_lld', 'Use the LLD linker', False),
BoolVariable('use_thinlto', 'Use ThinLTO', False),
BoolVariable(
'use_static_cpp',
'Link libgcc and libstdc++ statically for better portability',
False),
BoolVariable(
'use_ubsan',
'Use LLVM/GCC compiler undefined behavior sanitizer (UBSAN)',
False),
BoolVariable('use_asan',
'Use LLVM/GCC compiler address sanitizer (ASAN))', False),
BoolVariable('use_lsan',
'Use LLVM/GCC compiler leak sanitizer (LSAN))', False),
BoolVariable('use_tsan',
'Use LLVM/GCC compiler thread sanitizer (TSAN))', False),
BoolVariable('pulseaudio', 'Detect and use PulseAudio', True),
BoolVariable('udev', 'Use udev for gamepad connection callbacks',
False),
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),
BoolVariable('touch', 'Enable touch events', True),
BoolVariable(
'execinfo',
'Use libexecinfo on systems where glibc is not available', False),
]
def get_opts():
from SCons.Variables import BoolVariable, EnumVariable
return [
BoolVariable('use_llvm', 'Use the LLVM compiler', False),
BoolVariable(
'use_static_cpp',
'Link libgcc and libstdc++ statically for better portability',
False),
BoolVariable(
'use_ubsan',
'Use LLVM/GCC compiler undefined behavior sanitizer (UBSAN)',
False),
BoolVariable('use_asan',
'Use LLVM/GCC compiler address sanitizer (ASAN))', False),
BoolVariable('use_lsan',
'Use LLVM/GCC compiler leak sanitizer (LSAN))', False),
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),
BoolVariable(
'execinfo',
'Use libexecinfo on systems where glibc is not available', False),
]
def generate(env):
params = Variables(env['PARAMETER_SOURCE'], ARGUMENTS)
params.Add(EnumVariable('crosscompile', 'Enable cross compile', 'no', ['no', 'android', 'mingw', 'gcc']))
params.Update(env)
configGroup = None
try:
configReport = env.configReport
configGroup = 'Cross-Compile'
configReport.add('Enable cross compile', crosscompile, configGroup)
except:
pass
env.SetDefault(CROSSCOMPILE_CFLAGS = '')
env.SetDefault(CROSSCOMPILE_CPPFLAGS = '')
env.SetDefault(CROSSCOMPILE_CXXFLAGS = '')
env.SetDefault(CROSSCOMPILE_LINKFLAGS = '')
env.SetDefault(CROSSCOMPILE_LIBS = '')
env.SetDefault(CROSSCOMPILE_PROGRAM_LIBS = '')
if env['crosscompile'] == 'android':
android.generate(env, configGroup)
elif env['crosscompile'] == 'mingw':
mingw.generate(env, configGroup)
elif env['crosscompile'] == 'gcc':
gcc.generate(env, configGroup)
def get_opts():
from SCons.Variables import BoolVariable, EnumVariable
return [
("osxcross_sdk", "OSXCross SDK version", "darwin16"),
("MACOS_SDK_PATH", "Path to the macOS SDK", ""),
("VULKAN_SDK_PATH", "Path to the Vulkan SDK", ""),
EnumVariable("macports_clang", "Build using Clang from MacPorts", "no",
("no", "5.0", "devel")),
BoolVariable("debug_symbols",
"Add debugging symbols to release/release_debug builds",
True),
BoolVariable("separate_debug_symbols",
"Create a separate file containing debugging symbols",
False),
BoolVariable(
"use_ubsan",
"Use LLVM/GCC compiler undefined behavior sanitizer (UBSAN)",
False),
BoolVariable("use_asan",
"Use LLVM/GCC compiler address sanitizer (ASAN)", False),
BoolVariable("use_tsan",
"Use LLVM/GCC compiler thread sanitizer (TSAN)", False),
BoolVariable(
"use_coverage",
"Use instrumentation codes in the binary (e.g. for code coverage)",
False),
]
def to_scons(
self,
env: "Optional[SCEnvironment]" = None
) -> "Union[SCVariables, Tuple[str, str, Union[str, Dict[str, str]]]]":
"""Convert option to SCons variable"""
default = self.default
if isinstance(default, str) and "$" in default and env is not None:
default = env.subst(default)
elif not isinstance(default, (str, bool)):
raise TypeError(
f"Invalid defaults option with type '{type(default)}'")
if self.choices is None:
out = self.name, self.description, default
else:
out = self.name, self.description, default, self.choices
try:
if isinstance(self, BoolOption):
return BoolVariable(*out)
elif isinstance(self, PathOption):
return PathVariable(*out)
elif isinstance(self, EnumOption):
return EnumVariable(*out)
else:
return out
except Exception as err:
logger.error(
f"Error converting '{self.name}' to SCons variable:\n{out}")
raise err
def get_opts():
from SCons.Variables import BoolVariable, EnumVariable
return [
('osxcross_sdk', 'OSXCross SDK version', 'darwin14'),
('MACOS_SDK_PATH', 'Path to the macOS SDK', ''),
BoolVariable(
'use_static_mvk',
'Link MoltenVK statically as Level-0 driver (better portability) or use Vulkan ICD loader (enables validation layers)',
False),
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),
BoolVariable(
'use_ubsan',
'Use LLVM/GCC compiler undefined behavior sanitizer (UBSAN)',
False),
BoolVariable('use_asan',
'Use LLVM/GCC compiler address sanitizer (ASAN))', False),
BoolVariable('use_tsan',
'Use LLVM/GCC compiler thread sanitizer (TSAN))', 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_opts():
from SCons.Variables import BoolVariable, EnumVariable
return [
BoolVariable("use_llvm", "Use the LLVM compiler", False),
BoolVariable("use_lld", "Use the LLD linker", False),
BoolVariable("use_thinlto", "Use ThinLTO", False),
BoolVariable(
"use_static_cpp",
"Link libgcc and libstdc++ statically for better portability",
False),
BoolVariable(
"use_ubsan",
"Use LLVM/GCC compiler undefined behavior sanitizer (UBSAN)",
False),
BoolVariable("use_asan",
"Use LLVM/GCC compiler address sanitizer (ASAN))", False),
BoolVariable("use_lsan",
"Use LLVM/GCC compiler leak sanitizer (LSAN))", False),
BoolVariable("use_tsan",
"Use LLVM/GCC compiler thread sanitizer (TSAN))", False),
BoolVariable("pulseaudio", "Detect and use PulseAudio", True),
BoolVariable("udev", "Use udev for gamepad connection callbacks",
False),
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),
BoolVariable("touch", "Enable touch events", True),
BoolVariable(
"execinfo",
"Use libexecinfo on systems where glibc is not available", False),
]
def get_opts():
from SCons.Variables import BoolVariable, EnumVariable
return [
BoolVariable('use_llvm', 'Use the LLVM compiler', False),
BoolVariable(
'use_static_cpp',
'Link libgcc and libstdc++ statically for better portability',
False),
BoolVariable('use_sanitizer', 'Use LLVM compiler address sanitizer',
False),
BoolVariable(
'use_leak_sanitizer',
'Use LLVM compiler memory leaks sanitizer (implies use_sanitizer)',
False),
BoolVariable('pulseaudio', 'Detect & use pulseaudio', True),
BoolVariable('udev', 'Use udev for gamepad connection callbacks',
False),
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),
BoolVariable('touch', 'Enable touch events', True),
BoolVariable(
'execinfo',
'Use libexecinfo on systems where glibc is not available', False),
]
def get_opts():
from SCons.Variables import BoolVariable, EnumVariable
return [
BoolVariable("use_llvm", "Use the LLVM compiler", False),
BoolVariable(
"use_static_cpp",
"Link libgcc and libstdc++ statically for better portability",
False),
BoolVariable("use_coverage", "Test Godot coverage", False),
BoolVariable(
"use_ubsan",
"Use LLVM/GCC compiler undefined behavior sanitizer (UBSAN)",
False),
BoolVariable("use_asan",
"Use LLVM/GCC compiler address sanitizer (ASAN))", False),
BoolVariable("use_lsan",
"Use LLVM/GCC compiler leak sanitizer (LSAN))", False),
BoolVariable("use_tsan",
"Use LLVM/GCC compiler thread sanitizer (TSAN))", False),
EnumVariable("debug_symbols",
"Add debugging symbols to release/release_debug builds",
"yes", ("yes", "no")),
BoolVariable("separate_debug_symbols",
"Create a separate file containing debugging symbols",
False),
BoolVariable(
"execinfo",
"Use libexecinfo on systems where glibc is not available", 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 debug symbols to release version',
'yes', ('yes', 'no', 'full')),
BoolVariable('separate_debug_symbols',
'Create a separate file with the debug symbols', False),
]
def get_opts():
from SCons.Variables import EnumVariable
return [
('osxcross_sdk', 'OSXCross SDK version', 'darwin14'),
EnumVariable('debug_symbols', 'Add debug symbols to release version', 'yes', ('yes', 'no', 'full')),
]
def get_opts():
from SCons.Variables import EnumVariable
return [
EnumVariable("debug_symbols",
"Add debugging symbols to release builds", "yes",
("yes", "no", "full")),
]
def get_opts():
from SCons.Variables import BoolVariable, EnumVariable
return [
EnumVariable("debug_symbols",
"Add debugging symbols to release/release_debug builds",
"yes", ("yes", "no")),
]
def get_opts():
from SCons.Variables import BoolVariable, EnumVariable
return [
('osxcross_sdk', 'OSXCross SDK version', 'darwin14'),
EnumVariable('debug_symbols', 'Add debug symbols to release version', 'yes', ('yes', 'no', 'full')),
BoolVariable('separate_debug_symbols', 'Create a separate file with the debug symbols', False),
]
def get_opts():
from SCons.Variables import BoolVariable, EnumVariable
return [
("ANDROID_NDK_ROOT", "Path to the Android NDK", get_android_ndk_root()),
("ANDROID_SDK_ROOT", "Path to the Android SDK", get_android_sdk_root()),
("ndk_platform", 'Target platform (android-<api>, e.g. "android-24")', "android-24"),
EnumVariable("android_arch", "Target architecture", "arm64v8", ("armv7", "arm64v8", "x86", "x86_64")),
]
def _parse_default_command_line_options():
"""Parses the command line options controlling various build settings
@remarks
This contains variables that work across all builds. Build-specific variables
are discouraged, but would be irgnored by SCons' Variables class."""
command_line_variables = Variables(None, ARGUMENTS)
# Build configuration (also called build type in many SCons examples)
command_line_variables.Add(
BoolVariable(
'DEBUG',
'Whether to do an unoptimized debug build',
False
)
)
# Default architecture for the binaries. We follow the Debian practices,
# which, while clueless and chaotic, are at least widely used.
default_arch = 'amd64'
if 'armv7' in platform.uname()[4]:
default_arch = 'armhf'
if 'aarch64' in platform.uname()[4]:
default_arch = 'arm64'
# CPU architecture to target
command_line_variables.Add(
EnumVariable(
'TARGET_ARCH',
'CPU architecture the binary will run on',
default_arch,
allowed_values=('armhf', 'arm64', 'x86', 'amd64', 'any')
)
)
# Directory for intermediate files
command_line_variables.Add(
PathVariable(
'INTERMEDIATE_DIRECTORY',
'Directory in which intermediate build files will be stored',
'obj',
PathVariable.PathIsDirCreate
)
)
# Directory for intermediate files
command_line_variables.Add(
PathVariable(
'ARTIFACT_DIRECTORY',
'Directory in which build artifacts (outputs) will be stored',
'bin',
PathVariable.PathIsDirCreate
)
)
return command_line_variables
def get_opts():
from SCons.Variables import BoolVariable, EnumVariable
return [
("ANDROID_NDK_ROOT", "Path to the Android NDK", os.environ.get("ANDROID_NDK_ROOT", 0)),
("ndk_platform", 'Target platform (android-<api>, e.g. "android-24")', "android-24"),
EnumVariable("android_arch", "Target architecture", "armv7", ("armv7", "arm64v8", "x86", "x86_64")),
BoolVariable("android_neon", "Enable NEON support (armv7 only)", True),
]
def get_opts():
from SCons.Variables import BoolVariable, EnumVariable
return [
('osxcross_sdk', 'OSXCross SDK version', 'darwin14'),
('MACOS_SDK_PATH', 'Path to the macOS SDK', ''),
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),
]
def option(self, opts):
self.default()
opts.Add(
BoolVariable('debug', 'compilation in a debug mode',
self._default['debug']))
opts.Add(
BoolVariable('warnings', 'compilation with -Wall and similar',
self._default['warnings']))
opts.Add(BoolVariable('static', '', self._default['static']))
compilers = self._default['compilers']
default_compiler = compilers[0]
opts.Add(
EnumVariable('compiler', 'compiler tool used for the build',
default_compiler, compilers))
opts.Add('compiler_libs_suffix',
'Library suffix name like -vc80 or -mgw',
self._default['libs_suffix'])
opts.Add('rpath', 'A list of paths to search for shared libraries')
opts.Add('EXTRA_CCFLAGS', 'Specific user flags for c compiler', '')
opts.Add('EXTRA_CXXFLAGS', 'Specific user flags for c++ compiler', '')
opts.Add('EXTRA_CPPDEFINES', 'Specific c++ defines', '')
opts.Add('EXTRA_LINKFLAGS', 'Specific user flags for c++ linker', '')
opts.Add('EXTRA_CPPPATH', 'Specific user include path', '')
opts.Add('EXTRA_LIBPATH', 'Specific user library path', '')
opts.Add('EXTRA_LIBS', 'Specific user libraries', '')
if isinstance(platform, Win32):
opts.Add(
EnumVariable('TARGET_ARCH',
'Target Architecture',
'amd64' if is_64bit_environment() else 'x86',
allowed_values=('x86', 'amd64', 'i386', 'emt64',
'x86_64', 'ia64')))
opts.Add(
EnumVariable('MSVC_VERSION',
'Version ',
'' if not is_conda() else get_default_msvc(),
allowed_values=sorted(MsvcVersion.values()) +
['']))
def get_opts():
from SCons.Variables import BoolVariable, EnumVariable
return [
('ANDROID_NDK_ROOT', 'Path to the Android NDK', os.environ.get("ANDROID_NDK_ROOT", 0)),
('ndk_platform', 'Target platform (android-<api>, e.g. "android-18")', "android-18"),
EnumVariable('android_arch', 'Target architecture', "armv7", ('armv7', 'armv6', 'arm64v8', 'x86', 'x86_64')),
BoolVariable('android_neon', 'Enable NEON support (armv7 only)', True),
BoolVariable('android_stl', 'Enable Android STL support (for modules)', True)
]
def get_opts():
from SCons.Variables import BoolVariable, EnumVariable
return [
("ANDROID_NDK_ROOT", "Path to the Android NDK", get_android_ndk_root()),
("ANDROID_SDK_ROOT", "Path to the Android SDK", get_android_sdk_root()),
("ndk_platform", 'Target platform (android-<api>, e.g. "android-19")', "android-19"),
EnumVariable("android_arch", "Target architecture", "armv7", ("armv7", "arm64v8", "x86", "x86_64")),
BoolVariable("android_neon", "Enable NEON support (armv7 only)", True),
BoolVariable("android_rtti", "Enable rtti/exceptions support", False),
]
def get_opts():
from SCons.Variables import BoolVariable, EnumVariable
return [
('osxcross_sdk', 'OSXCross SDK version', 'darwin14'),
('MACOS_SDK_PATH', 'Path to the macOS SDK', ''),
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),
BoolVariable('use_ubsan', 'Use LLVM/GCC compiler undefined behavior sanitizer (UBSAN)', False),
BoolVariable('use_asan', 'Use LLVM/GCC compiler address sanitizer (ASAN))', False),
BoolVariable('use_tsan', 'Use LLVM/GCC compiler thread sanitizer (TSAN))', False),
]
def get_opts():
from SCons.Variables import BoolVariable, EnumVariable
return [
("osxcross_sdk", "OSXCross SDK version", "darwin14"),
("MACOS_SDK_PATH", "Path to the macOS SDK", ""),
EnumVariable("debug_symbols", "Add debugging symbols to release/release_debug builds", "yes", ("yes", "no")),
BoolVariable("separate_debug_symbols", "Create a separate file containing debugging symbols", False),
BoolVariable("use_ubsan", "Use LLVM/GCC compiler undefined behavior sanitizer (UBSAN)", False),
BoolVariable("use_asan", "Use LLVM/GCC compiler address sanitizer (ASAN))", False),
BoolVariable("use_tsan", "Use LLVM/GCC compiler thread sanitizer (TSAN))", False),
]
def get_opts():
from SCons.Variables import BoolVariable, EnumVariable
return [
EnumVariable("linker", "Linker program", "default",
("default", "bfd", "gold", "lld", "mold")),
BoolVariable("use_llvm", "Use the LLVM compiler", False),
BoolVariable(
"use_thinlto",
"Use ThinLTO (LLVM only, requires linker=lld, implies use_lto=yes)",
False),
BoolVariable(
"use_static_cpp",
"Link libgcc and libstdc++ statically for better portability",
True),
BoolVariable("use_coverage", "Test Godot coverage", False),
BoolVariable(
"use_ubsan",
"Use LLVM/GCC compiler undefined behavior sanitizer (UBSAN)",
False),
BoolVariable("use_asan",
"Use LLVM/GCC compiler address sanitizer (ASAN)", False),
BoolVariable("use_lsan", "Use LLVM/GCC compiler leak sanitizer (LSAN)",
False),
BoolVariable("use_tsan",
"Use LLVM/GCC compiler thread sanitizer (TSAN)", False),
BoolVariable("use_msan", "Use LLVM compiler memory sanitizer (MSAN)",
False),
BoolVariable("pulseaudio", "Detect and use PulseAudio", True),
BoolVariable("dbus", "Detect and use D-Bus to handle screensaver",
True),
BoolVariable(
"speechd",
"Detect and use Speech Dispatcher for Text-to-Speech support",
True),
BoolVariable("fontconfig",
"Detect and use fontconfig for system fonts support",
True),
BoolVariable("udev", "Use udev for gamepad connection callbacks",
True),
BoolVariable("x11", "Enable X11 display", True),
BoolVariable("debug_symbols",
"Add debugging symbols to release/release_debug builds",
True),
BoolVariable("separate_debug_symbols",
"Create a separate file containing debugging symbols",
False),
BoolVariable("touch", "Enable touch events", True),
BoolVariable(
"execinfo",
"Use libexecinfo on systems where glibc is not available", False),
]
def get_opts():
from SCons.Variables import BoolVariable, EnumVariable
return [
BoolVariable('use_llvm', 'Use the LLVM compiler', False),
BoolVariable('use_static_cpp', 'Link stdc++ statically', False),
BoolVariable('use_sanitizer', 'Use LLVM compiler address sanitizer', False),
BoolVariable('use_leak_sanitizer', 'Use LLVM compiler memory leaks sanitizer (implies use_sanitizer)', False),
BoolVariable('pulseaudio', 'Detect & use pulseaudio', True),
BoolVariable('udev', 'Use udev for gamepad connection callbacks', False),
EnumVariable('debug_symbols', 'Add debug symbols to release version', 'yes', ('yes', 'no', 'full')),
BoolVariable('touch', 'Enable touch events', True),
]
