def configure(env): platform = env["platform"] if platform not in supported_platforms: raise RuntimeError( "This module does not currently support building for this platform" ) env.add_module_version_string("mono") from SCons.Script import BoolVariable, PathVariable, Variables, Help default_mono_static = platform in ["iphone", "javascript"] default_mono_bundles_zlib = platform in ["javascript"] envvars = Variables() envvars.Add( PathVariable( "mono_prefix", "Path to the Mono installation directory for the target platform and architecture", "", PathVariable.PathAccept, )) envvars.Add( PathVariable( "mono_bcl", "Path to a custom Mono BCL (Base Class Library) directory for the target platform", "", PathVariable.PathAccept, )) envvars.Add( BoolVariable("mono_static", "Statically link Mono", default_mono_static)) envvars.Add( BoolVariable("mono_glue", "Build with the Mono glue sources", True)) envvars.Add(BoolVariable("build_cil", "Build C# solutions", True)) envvars.Add( BoolVariable( "copy_mono_root", "Make a copy of the Mono installation directory to bundle with the editor", True)) # TODO: It would be great if this could be detected automatically instead envvars.Add( BoolVariable( "mono_bundles_zlib", "Specify if the Mono runtime was built with bundled zlib", default_mono_bundles_zlib)) envvars.Update(env) Help(envvars.GenerateHelpText(env)) if env["mono_bundles_zlib"]: # Mono may come with zlib bundled for WASM or on newer version when built with MinGW. print( "This Mono runtime comes with zlib bundled. Disabling 'builtin_zlib'..." ) env["builtin_zlib"] = False thirdparty_zlib_dir = "#thirdparty/zlib/" env.Prepend(CPPPATH=[thirdparty_zlib_dir])
def configure(env): platform = env['platform'] if platform not in supported_platforms: raise RuntimeError( 'This module does not currently support building for this platform' ) env.use_ptrcall = True env.add_module_version_string('mono') from SCons.Script import BoolVariable, PathVariable, Variables, Help default_mono_static = platform in ['iphone', 'javascript'] default_mono_bundles_zlib = platform in ['javascript'] envvars = Variables() envvars.Add( PathVariable( 'mono_prefix', 'Path to the mono installation directory for the target platform and architecture', '', PathVariable.PathAccept)) envvars.Add( BoolVariable('mono_static', 'Statically link mono', default_mono_static)) envvars.Add( BoolVariable('mono_glue', 'Build with the mono glue sources', True)) envvars.Add( BoolVariable( 'copy_mono_root', 'Make a copy of the mono installation directory to bundle with the editor', False)) envvars.Add( BoolVariable('xbuild_fallback', 'If MSBuild is not found, fallback to xbuild', False)) # TODO: It would be great if this could be detected automatically instead envvars.Add( BoolVariable( 'mono_bundles_zlib', 'Specify if the Mono runtime was built with bundled zlib', default_mono_bundles_zlib)) envvars.Update(env) Help(envvars.GenerateHelpText(env)) if env['mono_bundles_zlib']: # Mono may come with zlib bundled for WASM or on newer version when built with MinGW. print( 'This Mono runtime comes with zlib bundled. Disabling \'builtin_zlib\'...' ) env['builtin_zlib'] = False thirdparty_zlib_dir = "#thirdparty/zlib/" env.Prepend(CPPPATH=[thirdparty_zlib_dir])
def configure(env): from SCons.Script import Variables, BoolVariable, Help opts = Variables() opts.Add( BoolVariable( "anl_use_long_period", "Use a long-period hash for noise (>256) to avoid having repeated patterns " "in exchange of a slight decrease in performance.", False)) opts.Add( BoolVariable( 'anl_use_expressions_camelcase', "Use 'camelCase' by default over the 'snake_case' for noise expressions.", False)) opts.Update(env) Help(opts.GenerateHelpText(env))
def configure(env): if env["platform"] not in [ "windows", "osx", "linuxbsd", "server", "android", "haiku", "javascript" ]: raise RuntimeError( "This module does not currently support building for this platform" ) env.use_ptrcall = True env.add_module_version_string("mono") from SCons.Script import BoolVariable, PathVariable, Variables, Help envvars = Variables() envvars.Add( PathVariable( "mono_prefix", "Path to the mono installation directory for the target platform and architecture", "", PathVariable.PathAccept, )) envvars.Add(BoolVariable("mono_static", "Statically link mono", False)) envvars.Add( BoolVariable("mono_glue", "Build with the mono glue sources", True)) envvars.Add( BoolVariable( "copy_mono_root", "Make a copy of the mono installation directory to bundle with the editor", False)) envvars.Add( BoolVariable("xbuild_fallback", "If MSBuild is not found, fallback to xbuild", False)) envvars.Update(env) Help(envvars.GenerateHelpText(env)) if env["platform"] == "javascript": # Mono wasm already has zlib builtin, so we need this workaround to avoid symbol collisions print("Compiling with Mono wasm disables 'builtin_zlib'") env["builtin_zlib"] = False thirdparty_zlib_dir = "#thirdparty/zlib/" env.Prepend(CPPPATH=[thirdparty_zlib_dir])
def configure(env): from SCons.Script import Variables, Help opts = Variables() opts.Add("geomtools_scale_factor", "The precision used for converting between integer and float coordinates throughout " + "poly backends implementations for computational robustness purposes.", "1e5") opts.Update(env) def help_format(env, opt, help, default, actual, aliases): if opt == "geomtools_scale_factor": fmt = "\n%s: %s.\n default: %s (based on CMP_EPSILON)\n actual: %s\n" else: fmt = "\n%s: %s.\n default: %s\n actual: %s\n" return fmt % (opt, help, default, actual) opts.FormatVariableHelpText = help_format Help(opts.GenerateHelpText(env))
def configure(env): if env['platform'] not in [ 'windows', 'osx', 'linuxbsd', 'server', 'android', 'haiku', 'javascript' ]: raise RuntimeError( 'This module does not currently support building for this platform' ) env.use_ptrcall = True env.add_module_version_string('mono') from SCons.Script import BoolVariable, PathVariable, Variables, Help envvars = Variables() envvars.Add( PathVariable( 'mono_prefix', 'Path to the mono installation directory for the target platform and architecture', '', PathVariable.PathAccept)) envvars.Add(BoolVariable('mono_static', 'Statically link mono', False)) envvars.Add( BoolVariable('mono_glue', 'Build with the mono glue sources', True)) envvars.Add( BoolVariable( 'copy_mono_root', 'Make a copy of the mono installation directory to bundle with the editor', False)) envvars.Add( BoolVariable('xbuild_fallback', 'If MSBuild is not found, fallback to xbuild', False)) envvars.Update(env) Help(envvars.GenerateHelpText(env)) if env['platform'] == 'javascript': # Mono wasm already has zlib builtin, so we need this workaround to avoid symbol collisions print('Compiling with Mono wasm disables \'builtin_zlib\'') env['builtin_zlib'] = False thirdparty_zlib_dir = "#thirdparty/zlib/" env.Prepend(CPPPATH=[thirdparty_zlib_dir])
def configure(env): from SCons.Script import Variables, BoolVariable, Help, Exit import goost opts = Variables() for name in goost.get_components(): opts.Add( BoolVariable("goost_%s_enabled" % (name), "Build %s component." % (name), True)) opts.Add( "goost_scale_factor", "The precision used for converting between integer and float coordinates.", "1e5") opts.Update(env) # Get a list of components which got disabled. disabled = [] for name in goost.get_components(): if not env["goost_%s_enabled" % (name)]: disabled.append(name) # Implicitly disable child components. for name in disabled: children = goost.get_child_components(name) for child_name in children: print("Goost: disabling `%s` component (%s)." % (child_name, name)) env["goost_%s_enabled" % (child_name)] = False def help_format(env, opt, help, default, actual, aliases): if opt == "goost_scale_factor": fmt = "\n%s: %s.\n default: %s (based on CMP_EPSILON)\n actual: %s\n" else: fmt = "\n%s: %s.\n default: %s\n actual: %s\n" return fmt % (opt, help, default, actual) opts.FormatVariableHelpText = help_format Help(opts.GenerateHelpText(env))
def __add_build_vars(env, build_type_names): """ Return Variables instance. """ assert isinstance(env, Environment) vs = Variables(None, ARGUMENTS) vs.Add( ListVariable(key='build', help=buildtype.help_msg(build_type_names), default=buildtype.default(build_type_names), names=build_type_names, map={})) vs.Add( EnumVariable(key='stage', help='build stage', default='compile', allowed_values=('compile', 'link'), map={}, ignorecase=0)) vs.Update(env) Help(vs.GenerateHelpText(env)) pass
def configure(env): from SCons.Script import Variables, BoolVariable, Help opts = Variables() # Config. components_config = {} components_enabled_by_default = True classes_config = {} classes_enabled_by_default = True # From `custom.py` file. try: import custom if hasattr(custom, "components"): components_config = custom.components if hasattr(custom, "components_enabled_by_default"): components_enabled_by_default = custom.components_enabled_by_default if hasattr(custom, "classes"): classes_config = custom.classes if hasattr(custom, "classes_enabled_by_default"): classes_enabled_by_default = custom.classes_enabled_by_default except ImportError: pass # From command-line (CLI arguments override arguments specified via file). opts.Add( BoolVariable( "goost_components_enabled", "Set to `no` to disable all components by default, and enable each component of interest manually", True)) # Get a list of all components and add them, regardless of configuration. for name in goost.get_components()["enabled"]: # All enabled by default. opts.Add( BoolVariable("goost_%s_enabled" % (name), "Build %s component." % (name), True)) # Math/Geometry. opts.Add( "goost_scale_factor", "The precision used for converting between integer and float coordinates.", "1e5") def help_format(env, opt, help, default, actual, aliases): if opt == "goost_scale_factor": fmt = "\n%s: %s.\n default: %s (based on CMP_EPSILON)\n actual: %s\n" else: fmt = "\n%s: %s.\n default: %s\n actual: %s\n" return fmt % (opt, help, default, actual) opts.FormatVariableHelpText = help_format # Must update environment to override `components_config` from CLI/file. # Do not call this method afterwards as the environment is going to be # updated manually. If you need to add more options not related to # components/classes, add them above. opts.Update(env) components = configure_components(env, components_config, components_enabled_by_default) classes = configure_classes(env, classes_config, classes_enabled_by_default) if env["verbose"]: for class_name in classes["enabled"]: # Report rightmost child components only. for component_name in reversed( goost.get_class_components(class_name)): skip = False if component_name in components["disabled"]: print( "Goost: Skipping class `%s`, because component `%s` is disabled." % (class_name, component_name)) skip = True if skip: break # Generate help text. Help(opts.GenerateHelpText(env))