SCons: Format buildsystem files with psf/black
Configured for a max line length of 120 characters. psf/black is very opinionated and purposely doesn't leave much room for configuration. The output is mostly OK so that should be fine for us, but some things worth noting: - Manually wrapped strings will be reflowed, so by using a line length of 120 for the sake of preserving readability for our long command calls, it also means that some manually wrapped strings are back on the same line and should be manually merged again. - Code generators using string concatenation extensively look awful, since black puts each operand on a single line. We need to refactor these generators to use more pythonic string formatting, for which many options are available (`%`, `format` or f-strings). - CI checks and a pre-commit hook will be added to ensure that future buildsystem changes are well-formatted.
This commit is contained in:
Rémi Verschelde
parent
0168709978
commit
cd4e46ee65
457
SConstruct
457
SConstruct
|
|
@ -26,48 +26,48 @@ platform_exporters = []
|
|||
platform_apis = []
|
||||
|
||||
for x in sorted(glob.glob("platform/*")):
|
||||
if (not os.path.isdir(x) or not os.path.exists(x + "/detect.py")):
|
||||
if not os.path.isdir(x) or not os.path.exists(x + "/detect.py"):
|
||||
continue
|
||||
tmppath = "./" + x
|
||||
|
||||
sys.path.insert(0, tmppath)
|
||||
import detect
|
||||
|
||||
if (os.path.exists(x + "/export/export.cpp")):
|
||||
if os.path.exists(x + "/export/export.cpp"):
|
||||
platform_exporters.append(x[9:])
|
||||
if (os.path.exists(x + "/api/api.cpp")):
|
||||
if os.path.exists(x + "/api/api.cpp"):
|
||||
platform_apis.append(x[9:])
|
||||
if (detect.is_active()):
|
||||
if detect.is_active():
|
||||
active_platforms.append(detect.get_name())
|
||||
active_platform_ids.append(x)
|
||||
if (detect.can_build()):
|
||||
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')
|
||||
sys.modules.pop("detect")
|
||||
|
||||
module_list = methods.detect_modules()
|
||||
|
||||
methods.save_active_platforms(active_platforms, active_platform_ids)
|
||||
|
||||
custom_tools = ['default']
|
||||
custom_tools = ["default"]
|
||||
|
||||
platform_arg = ARGUMENTS.get("platform", ARGUMENTS.get("p", False))
|
||||
|
||||
if os.name == "nt" and (platform_arg == "android" or ARGUMENTS.get("use_mingw", False)):
|
||||
custom_tools = ['mingw']
|
||||
elif platform_arg == 'javascript':
|
||||
custom_tools = ["mingw"]
|
||||
elif platform_arg == "javascript":
|
||||
# Use generic POSIX build toolchain for Emscripten.
|
||||
custom_tools = ['cc', 'c++', 'ar', 'link', 'textfile', 'zip']
|
||||
custom_tools = ["cc", "c++", "ar", "link", "textfile", "zip"]
|
||||
|
||||
env_base = Environment(tools=custom_tools)
|
||||
if 'TERM' in os.environ:
|
||||
env_base['ENV']['TERM'] = os.environ['TERM']
|
||||
env_base.AppendENVPath('PATH', os.getenv('PATH'))
|
||||
env_base.AppendENVPath('PKG_CONFIG_PATH', os.getenv('PKG_CONFIG_PATH'))
|
||||
if "TERM" in os.environ:
|
||||
env_base["ENV"]["TERM"] = os.environ["TERM"]
|
||||
env_base.AppendENVPath("PATH", os.getenv("PATH"))
|
||||
env_base.AppendENVPath("PKG_CONFIG_PATH", os.getenv("PKG_CONFIG_PATH"))
|
||||
env_base.disabled_modules = []
|
||||
env_base.use_ptrcall = False
|
||||
env_base.module_version_string = ""
|
||||
|
|
@ -94,7 +94,7 @@ env_base.SConsignFile(".sconsign{0}.dblite".format(pickle.HIGHEST_PROTOCOL))
|
|||
|
||||
# Build options
|
||||
|
||||
customs = ['custom.py']
|
||||
customs = ["custom.py"]
|
||||
|
||||
profile = ARGUMENTS.get("profile", False)
|
||||
if profile:
|
||||
|
|
@ -106,62 +106,62 @@ if profile:
|
|||
opts = Variables(customs, ARGUMENTS)
|
||||
|
||||
# Target build options
|
||||
opts.Add('arch', "Platform-dependent architecture (arm/arm64/x86/x64/mips/...)", '')
|
||||
opts.Add(EnumVariable('bits', "Target platform bits", 'default', ('default', '32', '64')))
|
||||
opts.Add('p', "Platform (alias for 'platform')", '')
|
||||
opts.Add('platform', "Target platform (%s)" % ('|'.join(platform_list), ), '')
|
||||
opts.Add(EnumVariable('target', "Compilation target", 'debug', ('debug', 'release_debug', 'release')))
|
||||
opts.Add(EnumVariable('optimize', "Optimization type", 'speed', ('speed', 'size')))
|
||||
opts.Add("arch", "Platform-dependent architecture (arm/arm64/x86/x64/mips/...)", "")
|
||||
opts.Add(EnumVariable("bits", "Target platform bits", "default", ("default", "32", "64")))
|
||||
opts.Add("p", "Platform (alias for 'platform')", "")
|
||||
opts.Add("platform", "Target platform (%s)" % ("|".join(platform_list),), "")
|
||||
opts.Add(EnumVariable("target", "Compilation target", "debug", ("debug", "release_debug", "release")))
|
||||
opts.Add(EnumVariable("optimize", "Optimization type", "speed", ("speed", "size")))
|
||||
|
||||
opts.Add(BoolVariable('tools', "Build the tools (a.k.a. the Godot editor)", True))
|
||||
opts.Add(BoolVariable('use_lto', 'Use link-time optimization', False))
|
||||
opts.Add(BoolVariable('use_precise_math_checks', 'Math checks use very precise epsilon (useful to debug the engine)', False))
|
||||
opts.Add(BoolVariable("tools", "Build the tools (a.k.a. the Godot editor)", True))
|
||||
opts.Add(BoolVariable("use_lto", "Use link-time optimization", False))
|
||||
opts.Add(BoolVariable("use_precise_math_checks", "Math checks use very precise epsilon (debug option)", False))
|
||||
|
||||
# Components
|
||||
opts.Add(BoolVariable('deprecated', "Enable deprecated features", True))
|
||||
opts.Add(BoolVariable('minizip', "Enable ZIP archive support using minizip", True))
|
||||
opts.Add(BoolVariable('xaudio2', "Enable the XAudio2 audio driver", False))
|
||||
opts.Add(BoolVariable("deprecated", "Enable deprecated features", True))
|
||||
opts.Add(BoolVariable("minizip", "Enable ZIP archive support using minizip", True))
|
||||
opts.Add(BoolVariable("xaudio2", "Enable the XAudio2 audio driver", False))
|
||||
|
||||
# Advanced options
|
||||
opts.Add(BoolVariable('verbose', "Enable verbose output for the compilation", False))
|
||||
opts.Add(BoolVariable('progress', "Show a progress indicator during compilation", True))
|
||||
opts.Add(EnumVariable('warnings', "Set the level of warnings emitted during compilation", 'all', ('extra', 'all', 'moderate', 'no')))
|
||||
opts.Add(BoolVariable('werror', "Treat compiler warnings as errors. Depends on the level of warnings set with 'warnings'", False))
|
||||
opts.Add(BoolVariable('dev', "If yes, alias for verbose=yes warnings=extra werror=yes", False))
|
||||
opts.Add('extra_suffix', "Custom extra suffix added to the base filename of all generated binary files", '')
|
||||
opts.Add(BoolVariable('vsproj', "Generate a Visual Studio solution", False))
|
||||
opts.Add(EnumVariable('macports_clang', "Build using Clang from MacPorts", 'no', ('no', '5.0', 'devel')))
|
||||
opts.Add(BoolVariable('disable_3d', "Disable 3D nodes for a smaller executable", False))
|
||||
opts.Add(BoolVariable('disable_advanced_gui', "Disable advanced GUI nodes and behaviors", False))
|
||||
opts.Add(BoolVariable('no_editor_splash', "Don't use the custom splash screen for the editor", False))
|
||||
opts.Add('system_certs_path', "Use this path as SSL certificates default for editor (for package maintainers)", '')
|
||||
opts.Add(BoolVariable("verbose", "Enable verbose output for the compilation", False))
|
||||
opts.Add(BoolVariable("progress", "Show a progress indicator during compilation", True))
|
||||
opts.Add(EnumVariable("warnings", "Level of compilation warnings", "all", ("extra", "all", "moderate", "no")))
|
||||
opts.Add(BoolVariable("werror", "Treat compiler warnings as errors", False))
|
||||
opts.Add(BoolVariable("dev", "If yes, alias for verbose=yes warnings=extra werror=yes", False))
|
||||
opts.Add("extra_suffix", "Custom extra suffix added to the base filename of all generated binary files", "")
|
||||
opts.Add(BoolVariable("vsproj", "Generate a Visual Studio solution", False))
|
||||
opts.Add(EnumVariable("macports_clang", "Build using Clang from MacPorts", "no", ("no", "5.0", "devel")))
|
||||
opts.Add(BoolVariable("disable_3d", "Disable 3D nodes for a smaller executable", False))
|
||||
opts.Add(BoolVariable("disable_advanced_gui", "Disable advanced GUI nodes and behaviors", False))
|
||||
opts.Add(BoolVariable("no_editor_splash", "Don't use the custom splash screen for the editor", False))
|
||||
opts.Add("system_certs_path", "Use this path as SSL certificates default for editor (for package maintainers)", "")
|
||||
|
||||
# Thirdparty libraries
|
||||
# opts.Add(BoolVariable('builtin_assimp', "Use the built-in Assimp library", True))
|
||||
opts.Add(BoolVariable('builtin_bullet', "Use the built-in Bullet library", True))
|
||||
opts.Add(BoolVariable('builtin_certs', "Bundle default SSL certificates to be used if you don't specify an override in the project settings", True))
|
||||
opts.Add(BoolVariable('builtin_enet', "Use the built-in ENet library", True))
|
||||
opts.Add(BoolVariable('builtin_freetype', "Use the built-in FreeType library", True))
|
||||
opts.Add(BoolVariable('builtin_glslang', "Use the built-in glslang library", True))
|
||||
opts.Add(BoolVariable('builtin_libogg', "Use the built-in libogg library", True))
|
||||
opts.Add(BoolVariable('builtin_libpng', "Use the built-in libpng library", True))
|
||||
opts.Add(BoolVariable('builtin_libtheora', "Use the built-in libtheora library", True))
|
||||
opts.Add(BoolVariable('builtin_libvorbis', "Use the built-in libvorbis library", True))
|
||||
opts.Add(BoolVariable('builtin_libvpx', "Use the built-in libvpx library", True))
|
||||
opts.Add(BoolVariable('builtin_libwebp', "Use the built-in libwebp library", True))
|
||||
opts.Add(BoolVariable('builtin_wslay', "Use the built-in wslay library", True))
|
||||
opts.Add(BoolVariable('builtin_mbedtls', "Use the built-in mbedTLS library", True))
|
||||
opts.Add(BoolVariable('builtin_miniupnpc', "Use the built-in miniupnpc library", True))
|
||||
opts.Add(BoolVariable('builtin_opus', "Use the built-in Opus library", True))
|
||||
opts.Add(BoolVariable('builtin_pcre2', "Use the built-in PCRE2 library", True))
|
||||
opts.Add(BoolVariable('builtin_pcre2_with_jit', "Use JIT compiler for the built-in PCRE2 library", True))
|
||||
opts.Add(BoolVariable('builtin_recast', "Use the built-in Recast library", True))
|
||||
opts.Add(BoolVariable('builtin_rvo2', "Use the built-in RVO2 library", True))
|
||||
opts.Add(BoolVariable('builtin_squish', "Use the built-in squish library", True))
|
||||
opts.Add(BoolVariable('builtin_vulkan', "Use the built-in Vulkan loader library and headers", True))
|
||||
opts.Add(BoolVariable('builtin_xatlas', "Use the built-in xatlas library", True))
|
||||
opts.Add(BoolVariable('builtin_zlib', "Use the built-in zlib library", True))
|
||||
opts.Add(BoolVariable('builtin_zstd', "Use the built-in Zstd library", True))
|
||||
opts.Add(BoolVariable("builtin_bullet", "Use the built-in Bullet library", True))
|
||||
opts.Add(BoolVariable("builtin_certs", "Use the built-in SSL certificates bundles", True))
|
||||
opts.Add(BoolVariable("builtin_enet", "Use the built-in ENet library", True))
|
||||
opts.Add(BoolVariable("builtin_freetype", "Use the built-in FreeType library", True))
|
||||
opts.Add(BoolVariable("builtin_glslang", "Use the built-in glslang library", True))
|
||||
opts.Add(BoolVariable("builtin_libogg", "Use the built-in libogg library", True))
|
||||
opts.Add(BoolVariable("builtin_libpng", "Use the built-in libpng library", True))
|
||||
opts.Add(BoolVariable("builtin_libtheora", "Use the built-in libtheora library", True))
|
||||
opts.Add(BoolVariable("builtin_libvorbis", "Use the built-in libvorbis library", True))
|
||||
opts.Add(BoolVariable("builtin_libvpx", "Use the built-in libvpx library", True))
|
||||
opts.Add(BoolVariable("builtin_libwebp", "Use the built-in libwebp library", True))
|
||||
opts.Add(BoolVariable("builtin_wslay", "Use the built-in wslay library", True))
|
||||
opts.Add(BoolVariable("builtin_mbedtls", "Use the built-in mbedTLS library", True))
|
||||
opts.Add(BoolVariable("builtin_miniupnpc", "Use the built-in miniupnpc library", True))
|
||||
opts.Add(BoolVariable("builtin_opus", "Use the built-in Opus library", True))
|
||||
opts.Add(BoolVariable("builtin_pcre2", "Use the built-in PCRE2 library", True))
|
||||
opts.Add(BoolVariable("builtin_pcre2_with_jit", "Use JIT compiler for the built-in PCRE2 library", True))
|
||||
opts.Add(BoolVariable("builtin_recast", "Use the built-in Recast library", True))
|
||||
opts.Add(BoolVariable("builtin_rvo2", "Use the built-in RVO2 library", True))
|
||||
opts.Add(BoolVariable("builtin_squish", "Use the built-in squish library", True))
|
||||
opts.Add(BoolVariable("builtin_vulkan", "Use the built-in Vulkan loader library and headers", True))
|
||||
opts.Add(BoolVariable("builtin_xatlas", "Use the built-in xatlas library", True))
|
||||
opts.Add(BoolVariable("builtin_zlib", "Use the built-in zlib library", True))
|
||||
opts.Add(BoolVariable("builtin_zstd", "Use the built-in Zstd library", True))
|
||||
|
||||
# Compilation environment setup
|
||||
opts.Add("CXX", "C++ compiler")
|
||||
|
|
@ -184,63 +184,64 @@ for x in module_list:
|
|||
tmppath = "./modules/" + x
|
||||
sys.path.insert(0, tmppath)
|
||||
import config
|
||||
|
||||
enabled_attr = getattr(config, "is_enabled", None)
|
||||
if (callable(enabled_attr) and not config.is_enabled()):
|
||||
if callable(enabled_attr) and not config.is_enabled():
|
||||
module_enabled = False
|
||||
sys.path.remove(tmppath)
|
||||
sys.modules.pop('config')
|
||||
opts.Add(BoolVariable('module_' + x + '_enabled', "Enable module '%s'" % (x, ), module_enabled))
|
||||
sys.modules.pop("config")
|
||||
opts.Add(BoolVariable("module_" + x + "_enabled", "Enable module '%s'" % (x,), module_enabled))
|
||||
|
||||
opts.Update(env_base) # update environment
|
||||
Help(opts.GenerateHelpText(env_base)) # generate help
|
||||
|
||||
# add default include paths
|
||||
|
||||
env_base.Prepend(CPPPATH=['#'])
|
||||
env_base.Prepend(CPPPATH=["#"])
|
||||
|
||||
# configure ENV for platform
|
||||
env_base.platform_exporters = platform_exporters
|
||||
env_base.platform_apis = platform_apis
|
||||
|
||||
if (env_base["use_precise_math_checks"]):
|
||||
env_base.Append(CPPDEFINES=['PRECISE_MATH_CHECKS'])
|
||||
if env_base["use_precise_math_checks"]:
|
||||
env_base.Append(CPPDEFINES=["PRECISE_MATH_CHECKS"])
|
||||
|
||||
if (env_base['target'] == 'debug'):
|
||||
env_base.Append(CPPDEFINES=['DEBUG_MEMORY_ALLOC','DISABLE_FORCED_INLINE'])
|
||||
if env_base["target"] == "debug":
|
||||
env_base.Append(CPPDEFINES=["DEBUG_MEMORY_ALLOC", "DISABLE_FORCED_INLINE"])
|
||||
|
||||
# The two options below speed up incremental builds, but reduce the certainty that all files
|
||||
# will properly be rebuilt. As such, we only enable them for debug (dev) builds, not release.
|
||||
|
||||
# To decide whether to rebuild a file, use the MD5 sum only if the timestamp has changed.
|
||||
# http://scons.org/doc/production/HTML/scons-user/ch06.html#idm139837621851792
|
||||
env_base.Decider('MD5-timestamp')
|
||||
env_base.Decider("MD5-timestamp")
|
||||
# Use cached implicit dependencies by default. Can be overridden by specifying `--implicit-deps-changed` in the command line.
|
||||
# http://scons.org/doc/production/HTML/scons-user/ch06s04.html
|
||||
env_base.SetOption('implicit_cache', 1)
|
||||
env_base.SetOption("implicit_cache", 1)
|
||||
|
||||
if (env_base['no_editor_splash']):
|
||||
env_base.Append(CPPDEFINES=['NO_EDITOR_SPLASH'])
|
||||
if env_base["no_editor_splash"]:
|
||||
env_base.Append(CPPDEFINES=["NO_EDITOR_SPLASH"])
|
||||
|
||||
if not env_base['deprecated']:
|
||||
env_base.Append(CPPDEFINES=['DISABLE_DEPRECATED'])
|
||||
if not env_base["deprecated"]:
|
||||
env_base.Append(CPPDEFINES=["DISABLE_DEPRECATED"])
|
||||
|
||||
env_base.platforms = {}
|
||||
|
||||
selected_platform = ""
|
||||
|
||||
if env_base['platform'] != "":
|
||||
selected_platform = env_base['platform']
|
||||
elif env_base['p'] != "":
|
||||
selected_platform = env_base['p']
|
||||
if env_base["platform"] != "":
|
||||
selected_platform = env_base["platform"]
|
||||
elif env_base["p"] != "":
|
||||
selected_platform = env_base["p"]
|
||||
env_base["platform"] = selected_platform
|
||||
else:
|
||||
# Missing `platform` argument, try to detect platform automatically
|
||||
if sys.platform.startswith('linux'):
|
||||
selected_platform = 'linuxbsd'
|
||||
elif sys.platform == 'darwin':
|
||||
selected_platform = 'osx'
|
||||
elif sys.platform == 'win32':
|
||||
selected_platform = 'windows'
|
||||
if sys.platform.startswith("linux"):
|
||||
selected_platform = "linuxbsd"
|
||||
elif sys.platform == "darwin":
|
||||
selected_platform = "osx"
|
||||
elif sys.platform == "win32":
|
||||
selected_platform = "windows"
|
||||
else:
|
||||
print("Could not detect platform automatically. Supported platforms:")
|
||||
for x in platform_list:
|
||||
|
|
@ -254,8 +255,7 @@ else:
|
|||
if selected_platform in ["linux", "bsd", "x11"]:
|
||||
if selected_platform == "x11":
|
||||
# Deprecated alias kept for compatibility.
|
||||
print('Platform "x11" has been renamed to "linuxbsd" in Godot 4.0. '
|
||||
'Building for platform "linuxbsd".')
|
||||
print('Platform "x11" has been renamed to "linuxbsd" in Godot 4.0. Building for platform "linuxbsd".')
|
||||
# Alias for convenience.
|
||||
selected_platform = "linuxbsd"
|
||||
|
||||
|
|
@ -263,17 +263,18 @@ if selected_platform in platform_list:
|
|||
tmppath = "./platform/" + selected_platform
|
||||
sys.path.insert(0, tmppath)
|
||||
import detect
|
||||
|
||||
if "create" in dir(detect):
|
||||
env = detect.create(env_base)
|
||||
else:
|
||||
env = env_base.Clone()
|
||||
|
||||
if env['dev']:
|
||||
env['verbose'] = True
|
||||
env['warnings'] = "extra"
|
||||
env['werror'] = True
|
||||
if env["dev"]:
|
||||
env["verbose"] = True
|
||||
env["warnings"] = "extra"
|
||||
env["werror"] = True
|
||||
|
||||
if env['vsproj']:
|
||||
if env["vsproj"]:
|
||||
env.vs_incs = []
|
||||
env.vs_srcs = []
|
||||
|
||||
|
|
@ -286,7 +287,7 @@ if selected_platform in platform_list:
|
|||
pieces = fname.split(".")
|
||||
if len(pieces) > 0:
|
||||
basename = pieces[0]
|
||||
basename = basename.replace('\\\\', '/')
|
||||
basename = basename.replace("\\\\", "/")
|
||||
if os.path.isfile(basename + ".h"):
|
||||
env.vs_incs = env.vs_incs + [basename + ".h"]
|
||||
elif os.path.isfile(basename + ".hpp"):
|
||||
|
|
@ -295,28 +296,29 @@ if selected_platform in platform_list:
|
|||
env.vs_srcs = env.vs_srcs + [basename + ".c"]
|
||||
elif os.path.isfile(basename + ".cpp"):
|
||||
env.vs_srcs = env.vs_srcs + [basename + ".cpp"]
|
||||
|
||||
env.AddToVSProject = AddToVSProject
|
||||
|
||||
env.extra_suffix = ""
|
||||
|
||||
if env["extra_suffix"] != '':
|
||||
env.extra_suffix += '.' + env["extra_suffix"]
|
||||
if env["extra_suffix"] != "":
|
||||
env.extra_suffix += "." + env["extra_suffix"]
|
||||
|
||||
# Environment flags
|
||||
CCFLAGS = env.get('CCFLAGS', '')
|
||||
env['CCFLAGS'] = ''
|
||||
CCFLAGS = env.get("CCFLAGS", "")
|
||||
env["CCFLAGS"] = ""
|
||||
env.Append(CCFLAGS=str(CCFLAGS).split())
|
||||
|
||||
CFLAGS = env.get('CFLAGS', '')
|
||||
env['CFLAGS'] = ''
|
||||
CFLAGS = env.get("CFLAGS", "")
|
||||
env["CFLAGS"] = ""
|
||||
env.Append(CFLAGS=str(CFLAGS).split())
|
||||
|
||||
CXXFLAGS = env.get('CXXFLAGS', '')
|
||||
env['CXXFLAGS'] = ''
|
||||
CXXFLAGS = env.get("CXXFLAGS", "")
|
||||
env["CXXFLAGS"] = ""
|
||||
env.Append(CXXFLAGS=str(CXXFLAGS).split())
|
||||
|
||||
LINKFLAGS = env.get('LINKFLAGS', '')
|
||||
env['LINKFLAGS'] = ''
|
||||
LINKFLAGS = env.get("LINKFLAGS", "")
|
||||
env["LINKFLAGS"] = ""
|
||||
env.Append(LINKFLAGS=str(LINKFLAGS).split())
|
||||
|
||||
# Platform specific flags
|
||||
|
|
@ -335,12 +337,12 @@ if selected_platform in platform_list:
|
|||
if not env.msvc:
|
||||
# Specifying GNU extensions support explicitly, which are supported by
|
||||
# both GCC and Clang. Both currently default to gnu11 and gnu++14.
|
||||
env.Prepend(CFLAGS=['-std=gnu11'])
|
||||
env.Prepend(CXXFLAGS=['-std=gnu++17'])
|
||||
env.Prepend(CFLAGS=["-std=gnu11"])
|
||||
env.Prepend(CXXFLAGS=["-std=gnu++17"])
|
||||
else:
|
||||
# MSVC doesn't have clear C standard support, /std only covers C++.
|
||||
# We apply it to CCFLAGS (both C and C++ code) in case it impacts C features.
|
||||
env.Prepend(CCFLAGS=['/std:c++17'])
|
||||
env.Prepend(CCFLAGS=["/std:c++17"])
|
||||
|
||||
# Enforce our minimal compiler version requirements
|
||||
cc_version = methods.get_compiler_version(env) or [-1, -1]
|
||||
|
|
@ -351,16 +353,20 @@ if selected_platform in platform_list:
|
|||
# GCC 8 before 8.4 has a regression in the support of guaranteed copy elision
|
||||
# which causes a build failure: https://gcc.gnu.org/bugzilla/show_bug.cgi?id=86521
|
||||
if cc_version_major == 8 and cc_version_minor < 4:
|
||||
print("Detected GCC 8 version < 8.4, which is not supported due to a "
|
||||
print(
|
||||
"Detected GCC 8 version < 8.4, which is not supported due to a "
|
||||
"regression in its C++17 guaranteed copy elision support. Use a "
|
||||
"newer GCC version, or Clang 6 or later by passing \"use_llvm=yes\" "
|
||||
"to the SCons command line.")
|
||||
'newer GCC version, or Clang 6 or later by passing "use_llvm=yes" '
|
||||
"to the SCons command line."
|
||||
)
|
||||
sys.exit(255)
|
||||
elif cc_version_major < 7:
|
||||
print("Detected GCC version older than 7, which does not fully support "
|
||||
print(
|
||||
"Detected GCC version older than 7, which does not fully support "
|
||||
"C++17. Supported versions are GCC 7, 9 and later. Use a newer GCC "
|
||||
"version, or Clang 6 or later by passing \"use_llvm=yes\" to the "
|
||||
"SCons command line.")
|
||||
'version, or Clang 6 or later by passing "use_llvm=yes" to the '
|
||||
"SCons command line."
|
||||
)
|
||||
sys.exit(255)
|
||||
elif methods.using_clang(env):
|
||||
# Apple LLVM versions differ from upstream LLVM version \o/, compare
|
||||
|
|
@ -368,87 +374,98 @@ if selected_platform in platform_list:
|
|||
if env["platform"] == "osx" or env["platform"] == "iphone":
|
||||
vanilla = methods.is_vanilla_clang(env)
|
||||
if vanilla and cc_version_major < 6:
|
||||
print("Detected Clang version older than 6, which does not fully support "
|
||||
"C++17. Supported versions are Clang 6 and later.")
|
||||
print(
|
||||
"Detected Clang version older than 6, which does not fully support "
|
||||
"C++17. Supported versions are Clang 6 and later."
|
||||
)
|
||||
sys.exit(255)
|
||||
elif not vanilla and cc_version_major < 10:
|
||||
print("Detected Apple Clang version older than 10, which does not fully "
|
||||
"support C++17. Supported versions are Apple Clang 10 and later.")
|
||||
print(
|
||||
"Detected Apple Clang version older than 10, which does not fully "
|
||||
"support C++17. Supported versions are Apple Clang 10 and later."
|
||||
)
|
||||
sys.exit(255)
|
||||
elif cc_version_major < 6:
|
||||
print("Detected Clang version older than 6, which does not fully support "
|
||||
"C++17. Supported versions are Clang 6 and later.")
|
||||
print(
|
||||
"Detected Clang version older than 6, which does not fully support "
|
||||
"C++17. Supported versions are Clang 6 and later."
|
||||
)
|
||||
sys.exit(255)
|
||||
|
||||
# Configure compiler warnings
|
||||
if env.msvc:
|
||||
# Truncations, narrowing conversions, signed/unsigned comparisons...
|
||||
disable_nonessential_warnings = ['/wd4267', '/wd4244', '/wd4305', '/wd4018', '/wd4800']
|
||||
if (env["warnings"] == 'extra'):
|
||||
env.Append(CCFLAGS=['/Wall']) # Implies /W4
|
||||
elif (env["warnings"] == 'all'):
|
||||
env.Append(CCFLAGS=['/W3'] + disable_nonessential_warnings)
|
||||
elif (env["warnings"] == 'moderate'):
|
||||
env.Append(CCFLAGS=['/W2'] + disable_nonessential_warnings)
|
||||
disable_nonessential_warnings = ["/wd4267", "/wd4244", "/wd4305", "/wd4018", "/wd4800"]
|
||||
if env["warnings"] == "extra":
|
||||
env.Append(CCFLAGS=["/Wall"]) # Implies /W4
|
||||
elif env["warnings"] == "all":
|
||||
env.Append(CCFLAGS=["/W3"] + disable_nonessential_warnings)
|
||||
elif env["warnings"] == "moderate":
|
||||
env.Append(CCFLAGS=["/W2"] + disable_nonessential_warnings)
|
||||
else: # 'no'
|
||||
env.Append(CCFLAGS=['/w'])
|
||||
env.Append(CCFLAGS=["/w"])
|
||||
# Set exception handling model to avoid warnings caused by Windows system headers.
|
||||
env.Append(CCFLAGS=['/EHsc'])
|
||||
if (env["werror"]):
|
||||
env.Append(CCFLAGS=['/WX'])
|
||||
env.Append(CCFLAGS=["/EHsc"])
|
||||
if env["werror"]:
|
||||
env.Append(CCFLAGS=["/WX"])
|
||||
# Force to use Unicode encoding
|
||||
env.Append(MSVC_FLAGS=['/utf8'])
|
||||
env.Append(MSVC_FLAGS=["/utf8"])
|
||||
else: # Rest of the world
|
||||
shadow_local_warning = []
|
||||
all_plus_warnings = ['-Wwrite-strings']
|
||||
all_plus_warnings = ["-Wwrite-strings"]
|
||||
|
||||
if methods.using_gcc(env):
|
||||
if cc_version_major >= 7:
|
||||
shadow_local_warning = ['-Wshadow-local']
|
||||
shadow_local_warning = ["-Wshadow-local"]
|
||||
|
||||
if (env["warnings"] == 'extra'):
|
||||
env.Append(CCFLAGS=['-Wall', '-Wextra', '-Wno-unused-parameter']
|
||||
+ all_plus_warnings + shadow_local_warning)
|
||||
env.Append(CXXFLAGS=['-Wctor-dtor-privacy', '-Wnon-virtual-dtor'])
|
||||
if env["warnings"] == "extra":
|
||||
env.Append(CCFLAGS=["-Wall", "-Wextra", "-Wno-unused-parameter"] + all_plus_warnings + shadow_local_warning)
|
||||
env.Append(CXXFLAGS=["-Wctor-dtor-privacy", "-Wnon-virtual-dtor"])
|
||||
if methods.using_gcc(env):
|
||||
env.Append(CCFLAGS=['-Walloc-zero',
|
||||
'-Wduplicated-branches', '-Wduplicated-cond',
|
||||
'-Wstringop-overflow=4', '-Wlogical-op'])
|
||||
env.Append(
|
||||
CCFLAGS=[
|
||||
"-Walloc-zero",
|
||||
"-Wduplicated-branches",
|
||||
"-Wduplicated-cond",
|
||||
"-Wstringop-overflow=4",
|
||||
"-Wlogical-op",
|
||||
]
|
||||
)
|
||||
# -Wnoexcept was removed temporarily due to GH-36325.
|
||||
env.Append(CXXFLAGS=['-Wplacement-new=1'])
|
||||
env.Append(CXXFLAGS=["-Wplacement-new=1"])
|
||||
if cc_version_major >= 9:
|
||||
env.Append(CCFLAGS=['-Wattribute-alias=2'])
|
||||
env.Append(CCFLAGS=["-Wattribute-alias=2"])
|
||||
if methods.using_clang(env):
|
||||
env.Append(CCFLAGS=['-Wimplicit-fallthrough'])
|
||||
elif (env["warnings"] == 'all'):
|
||||
env.Append(CCFLAGS=['-Wall'] + shadow_local_warning)
|
||||
elif (env["warnings"] == 'moderate'):
|
||||
env.Append(CCFLAGS=['-Wall', '-Wno-unused'] + shadow_local_warning)
|
||||
env.Append(CCFLAGS=["-Wimplicit-fallthrough"])
|
||||
elif env["warnings"] == "all":
|
||||
env.Append(CCFLAGS=["-Wall"] + shadow_local_warning)
|
||||
elif env["warnings"] == "moderate":
|
||||
env.Append(CCFLAGS=["-Wall", "-Wno-unused"] + shadow_local_warning)
|
||||
else: # 'no'
|
||||
env.Append(CCFLAGS=['-w'])
|
||||
if (env["werror"]):
|
||||
env.Append(CCFLAGS=['-Werror'])
|
||||
env.Append(CCFLAGS=["-w"])
|
||||
if env["werror"]:
|
||||
env.Append(CCFLAGS=["-Werror"])
|
||||
# FIXME: Temporary workaround after the Vulkan merge, remove once warnings are fixed.
|
||||
if methods.using_gcc(env):
|
||||
env.Append(CXXFLAGS=['-Wno-error=cpp'])
|
||||
env.Append(CXXFLAGS=["-Wno-error=cpp"])
|
||||
else:
|
||||
env.Append(CXXFLAGS=['-Wno-error=#warnings'])
|
||||
env.Append(CXXFLAGS=["-Wno-error=#warnings"])
|
||||
else: # always enable those errors
|
||||
env.Append(CCFLAGS=['-Werror=return-type'])
|
||||
env.Append(CCFLAGS=["-Werror=return-type"])
|
||||
|
||||
if (hasattr(detect, 'get_program_suffix')):
|
||||
if hasattr(detect, "get_program_suffix"):
|
||||
suffix = "." + detect.get_program_suffix()
|
||||
else:
|
||||
suffix = "." + selected_platform
|
||||
|
||||
if (env["target"] == "release"):
|
||||
if env["target"] == "release":
|
||||
if env["tools"]:
|
||||
print("Tools can only be built with targets 'debug' and 'release_debug'.")
|
||||
sys.exit(255)
|
||||
suffix += ".opt"
|
||||
env.Append(CPPDEFINES=['NDEBUG'])
|
||||
env.Append(CPPDEFINES=["NDEBUG"])
|
||||
|
||||
elif (env["target"] == "release_debug"):
|
||||
elif env["target"] == "release_debug":
|
||||
if env["tools"]:
|
||||
suffix += ".opt.tools"
|
||||
else:
|
||||
|
|
@ -461,27 +478,28 @@ if selected_platform in platform_list:
|
|||
|
||||
if env["arch"] != "":
|
||||
suffix += "." + env["arch"]
|
||||
elif (env["bits"] == "32"):
|
||||
elif env["bits"] == "32":
|
||||
suffix += ".32"
|
||||
elif (env["bits"] == "64"):
|
||||
elif env["bits"] == "64":
|
||||
suffix += ".64"
|
||||
|
||||
suffix += env.extra_suffix
|
||||
|
||||
sys.path.remove(tmppath)
|
||||
sys.modules.pop('detect')
|
||||
sys.modules.pop("detect")
|
||||
|
||||
env.module_list = []
|
||||
env.module_icons_paths = []
|
||||
env.doc_class_path = {}
|
||||
|
||||
for x in sorted(module_list):
|
||||
if not env['module_' + x + '_enabled']:
|
||||
if not env["module_" + x + "_enabled"]:
|
||||
continue
|
||||
tmppath = "./modules/" + x
|
||||
sys.path.insert(0, tmppath)
|
||||
env.current_module = x
|
||||
import config
|
||||
|
||||
if config.can_build(env, selected_platform):
|
||||
config.configure(env)
|
||||
env.module_list.append(x)
|
||||
|
|
@ -503,7 +521,7 @@ if selected_platform in platform_list:
|
|||
env.module_icons_paths.append("modules/" + x + "/" + "icons")
|
||||
|
||||
sys.path.remove(tmppath)
|
||||
sys.modules.pop('config')
|
||||
sys.modules.pop("config")
|
||||
|
||||
methods.update_version(env.module_version_string)
|
||||
|
||||
|
|
@ -522,45 +540,66 @@ if selected_platform in platform_list:
|
|||
env["LIBSUFFIX"] = suffix + env["LIBSUFFIX"]
|
||||
env["SHLIBSUFFIX"] = suffix + env["SHLIBSUFFIX"]
|
||||
|
||||
if (env.use_ptrcall):
|
||||
env.Append(CPPDEFINES=['PTRCALL_ENABLED'])
|
||||
if env['tools']:
|
||||
env.Append(CPPDEFINES=['TOOLS_ENABLED'])
|
||||
if env['disable_3d']:
|
||||
if env['tools']:
|
||||
print("Build option 'disable_3d=yes' cannot be used with 'tools=yes' (editor), only with 'tools=no' (export template).")
|
||||
if env.use_ptrcall:
|
||||
env.Append(CPPDEFINES=["PTRCALL_ENABLED"])
|
||||
if env["tools"]:
|
||||
env.Append(CPPDEFINES=["TOOLS_ENABLED"])
|
||||
if env["disable_3d"]:
|
||||
if env["tools"]:
|
||||
print(
|
||||
"Build option 'disable_3d=yes' cannot be used with 'tools=yes' (editor), "
|
||||
"only with 'tools=no' (export template)."
|
||||
)
|
||||
sys.exit(255)
|
||||
else:
|
||||
env.Append(CPPDEFINES=['_3D_DISABLED'])
|
||||
if env['disable_advanced_gui']:
|
||||
if env['tools']:
|
||||
print("Build option 'disable_advanced_gui=yes' cannot be used with 'tools=yes' (editor), only with 'tools=no' (export template).")
|
||||
env.Append(CPPDEFINES=["_3D_DISABLED"])
|
||||
if env["disable_advanced_gui"]:
|
||||
if env["tools"]:
|
||||
print(
|
||||
"Build option 'disable_advanced_gui=yes' cannot be used with 'tools=yes' (editor), "
|
||||
"only with 'tools=no' (export template)."
|
||||
)
|
||||
sys.exit(255)
|
||||
else:
|
||||
env.Append(CPPDEFINES=['ADVANCED_GUI_DISABLED'])
|
||||
if env['minizip']:
|
||||
env.Append(CPPDEFINES=['MINIZIP_ENABLED'])
|
||||
env.Append(CPPDEFINES=["ADVANCED_GUI_DISABLED"])
|
||||
if env["minizip"]:
|
||||
env.Append(CPPDEFINES=["MINIZIP_ENABLED"])
|
||||
|
||||
editor_module_list = ['regex']
|
||||
editor_module_list = ["regex"]
|
||||
for x in editor_module_list:
|
||||
if not env['module_' + x + '_enabled']:
|
||||
if env['tools']:
|
||||
print("Build option 'module_" + x + "_enabled=no' cannot be used with 'tools=yes' (editor), only with 'tools=no' (export template).")
|
||||
if not env["module_" + x + "_enabled"]:
|
||||
if env["tools"]:
|
||||
print(
|
||||
"Build option 'module_" + x + "_enabled=no' cannot be used with 'tools=yes' (editor), "
|
||||
"only with 'tools=no' (export template)."
|
||||
)
|
||||
sys.exit(255)
|
||||
|
||||
if not env['verbose']:
|
||||
if not env["verbose"]:
|
||||
methods.no_verbose(sys, env)
|
||||
|
||||
if (not env["platform"] == "server"):
|
||||
env.Append(BUILDERS = { 'GLES2_GLSL' : env.Builder(action=run_in_subprocess(gles_builders.build_gles2_headers), suffix='glsl.gen.h', src_suffix='.glsl')})
|
||||
env.Append(BUILDERS = { 'RD_GLSL' : env.Builder(action=run_in_subprocess(gles_builders.build_rd_headers), suffix='glsl.gen.h', src_suffix='.glsl')})
|
||||
if not env["platform"] == "server":
|
||||
env.Append(
|
||||
BUILDERS={
|
||||
"GLES2_GLSL": env.Builder(
|
||||
action=run_in_subprocess(gles_builders.build_gles2_headers), suffix="glsl.gen.h", src_suffix=".glsl"
|
||||
)
|
||||
}
|
||||
)
|
||||
env.Append(
|
||||
BUILDERS={
|
||||
"RD_GLSL": env.Builder(
|
||||
action=run_in_subprocess(gles_builders.build_rd_headers), suffix="glsl.gen.h", src_suffix=".glsl"
|
||||
)
|
||||
}
|
||||
)
|
||||
|
||||
scons_cache_path = os.environ.get("SCONS_CACHE")
|
||||
if scons_cache_path != None:
|
||||
CacheDir(scons_cache_path)
|
||||
print("Scons cache enabled... (path: '" + scons_cache_path + "')")
|
||||
|
||||
Export('env')
|
||||
Export("env")
|
||||
|
||||
# build subdirs, the build order is dependent on link order.
|
||||
|
||||
|
|
@ -577,16 +616,16 @@ if selected_platform in platform_list:
|
|||
SConscript("platform/" + selected_platform + "/SCsub") # build selected platform
|
||||
|
||||
# Microsoft Visual Studio Project Generation
|
||||
if env['vsproj']:
|
||||
env['CPPPATH'] = [Dir(path) for path in env['CPPPATH']]
|
||||
if env["vsproj"]:
|
||||
env["CPPPATH"] = [Dir(path) for path in env["CPPPATH"]]
|
||||
methods.generate_vs_project(env, GetOption("num_jobs"))
|
||||
methods.generate_cpp_hint_file("cpp.hint")
|
||||
|
||||
# Check for the existence of headers
|
||||
conf = Configure(env)
|
||||
if ("check_c_headers" in env):
|
||||
if "check_c_headers" in env:
|
||||
for header in env["check_c_headers"]:
|
||||
if (conf.CheckCHeader(header[0])):
|
||||
if conf.CheckCHeader(header[0]):
|
||||
env.AppendUnique(CPPDEFINES=[header[1]])
|
||||
|
||||
elif selected_platform != "":
|
||||
|
|
@ -608,15 +647,15 @@ elif selected_platform != "":
|
|||
sys.exit(255)
|
||||
|
||||
# The following only makes sense when the env is defined, and assumes it is
|
||||
if 'env' in locals():
|
||||
if "env" in locals():
|
||||
screen = sys.stdout
|
||||
# Progress reporting is not available in non-TTY environments since it
|
||||
# messes with the output (for example, when writing to a file)
|
||||
show_progress = (env['progress'] and sys.stdout.isatty())
|
||||
show_progress = env["progress"] and sys.stdout.isatty()
|
||||
node_count = 0
|
||||
node_count_max = 0
|
||||
node_count_interval = 1
|
||||
node_count_fname = str(env.Dir('#')) + '/.scons_node_count'
|
||||
node_count_fname = str(env.Dir("#")) + "/.scons_node_count"
|
||||
|
||||
import time, math
|
||||
|
||||
|
|
@ -626,8 +665,12 @@ if 'env' in locals():
|
|||
self.path = path
|
||||
self.limit = limit
|
||||
self.exponent_scale = math.log(2) / half_life
|
||||
if env['verbose'] and path != None:
|
||||
screen.write('Current cache limit is ' + self.convert_size(limit) + ' (used: ' + self.convert_size(self.get_size(path)) + ')\n')
|
||||
if env["verbose"] and path != None:
|
||||
screen.write(
|
||||
"Current cache limit is {} (used: {})\n".format(
|
||||
self.convert_size(limit), self.convert_size(self.get_size(path))
|
||||
)
|
||||
)
|
||||
self.delete(self.file_list())
|
||||
|
||||
def __call__(self, node, *args, **kw):
|
||||
|
|
@ -635,22 +678,22 @@ if 'env' in locals():
|
|||
if show_progress:
|
||||
# Print the progress percentage
|
||||
node_count += node_count_interval
|
||||
if (node_count_max > 0 and node_count <= node_count_max):
|
||||
screen.write('\r[%3d%%] ' % (node_count * 100 / node_count_max))
|
||||
if node_count_max > 0 and node_count <= node_count_max:
|
||||
screen.write("\r[%3d%%] " % (node_count * 100 / node_count_max))
|
||||
screen.flush()
|
||||
elif (node_count_max > 0 and node_count > node_count_max):
|
||||
screen.write('\r[100%] ')
|
||||
elif node_count_max > 0 and node_count > node_count_max:
|
||||
screen.write("\r[100%] ")
|
||||
screen.flush()
|
||||
else:
|
||||
screen.write('\r[Initial build] ')
|
||||
screen.write("\r[Initial build] ")
|
||||
screen.flush()
|
||||
|
||||
def delete(self, files):
|
||||
if len(files) == 0:
|
||||
return
|
||||
if env['verbose']:
|
||||
if env["verbose"]:
|
||||
# Utter something
|
||||
screen.write('\rPurging %d %s from cache...\n' % (len(files), len(files) > 1 and 'files' or 'file'))
|
||||
screen.write("\rPurging %d %s from cache...\n" % (len(files), len(files) > 1 and "files" or "file"))
|
||||
[os.remove(f) for f in files]
|
||||
|
||||
def file_list(self):
|
||||
|
|
@ -659,7 +702,7 @@ if 'env' in locals():
|
|||
return []
|
||||
# Gather a list of (filename, (size, atime)) within the
|
||||
# cache directory
|
||||
file_stat = [(x, os.stat(x)[6:8]) for x in glob.glob(os.path.join(self.path, '*', '*'))]
|
||||
file_stat = [(x, os.stat(x)[6:8]) for x in glob.glob(os.path.join(self.path, "*", "*"))]
|
||||
if file_stat == []:
|
||||
# Nothing to do
|
||||
return []
|
||||
|
|
@ -693,7 +736,7 @@ if 'env' in locals():
|
|||
s = round(size_bytes / p, 2)
|
||||
return "%s %s" % (int(s) if i == 0 else s, size_name[i])
|
||||
|
||||
def get_size(self, start_path = '.'):
|
||||
def get_size(self, start_path="."):
|
||||
total_size = 0
|
||||
for dirpath, dirnames, filenames in os.walk(start_path):
|
||||
for f in filenames:
|
||||
|
|
@ -703,8 +746,8 @@ if 'env' in locals():
|
|||
|
||||
def progress_finish(target, source, env):
|
||||
global node_count, progressor
|
||||
with open(node_count_fname, 'w') as f:
|
||||
f.write('%d\n' % node_count)
|
||||
with open(node_count_fname, "w") as f:
|
||||
f.write("%d\n" % node_count)
|
||||
progressor.delete(progressor.file_list())
|
||||
|
||||
try:
|
||||
|
|
@ -720,5 +763,5 @@ if 'env' in locals():
|
|||
progressor = cache_progress(cache_directory, cache_limit)
|
||||
Progress(progressor, interval=node_count_interval)
|
||||
|
||||
progress_finish_command = Command('progress_finish', [], progress_finish)
|
||||
progress_finish_command = Command("progress_finish", [], progress_finish)
|
||||
AlwaysBuild(progress_finish_command)
|
||||
|
|
|
|||
67
core/SCsub
67
core/SCsub
|
|
@ -1,6 +1,6 @@
|
|||
#!/usr/bin/env python
|
||||
|
||||
Import('env')
|
||||
Import("env")
|
||||
|
||||
import core_builders
|
||||
import make_binders
|
||||
|
|
@ -11,17 +11,18 @@ env.core_sources = []
|
|||
|
||||
# Generate AES256 script encryption key
|
||||
import os
|
||||
|
||||
txt = "0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0"
|
||||
if ("SCRIPT_AES256_ENCRYPTION_KEY" in os.environ):
|
||||
if "SCRIPT_AES256_ENCRYPTION_KEY" in os.environ:
|
||||
e = os.environ["SCRIPT_AES256_ENCRYPTION_KEY"]
|
||||
txt = ""
|
||||
ec_valid = True
|
||||
if (len(e) != 64):
|
||||
if len(e) != 64:
|
||||
ec_valid = False
|
||||
else:
|
||||
|
||||
for i in range(len(e) >> 1):
|
||||
if (i > 0):
|
||||
if i > 0:
|
||||
txt += ","
|
||||
txts = "0x" + e[i * 2 : i * 2 + 2]
|
||||
try:
|
||||
|
|
@ -29,13 +30,13 @@ if ("SCRIPT_AES256_ENCRYPTION_KEY" in os.environ):
|
|||
except:
|
||||
ec_valid = False
|
||||
txt += txts
|
||||
if (not ec_valid):
|
||||
if not ec_valid:
|
||||
txt = "0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0"
|
||||
print("Invalid AES256 encryption key, not 64 bits hex: " + e)
|
||||
|
||||
# NOTE: It is safe to generate this file here, since this is still executed serially
|
||||
with open("script_encryption_key.gen.cpp", "w") as f:
|
||||
f.write("#include \"core/project_settings.h\"\nuint8_t script_encryption_key[32]={" + txt + "};\n")
|
||||
f.write('#include "core/project_settings.h"\nuint8_t script_encryption_key[32]={' + txt + "};\n")
|
||||
|
||||
|
||||
# Add required thirdparty code.
|
||||
|
|
@ -49,7 +50,6 @@ thirdparty_misc_sources = [
|
|||
# C sources
|
||||
"fastlz.c",
|
||||
"smaz.c",
|
||||
|
||||
# C++ sources
|
||||
"hq2x.cpp",
|
||||
"pcg.cpp",
|
||||
|
|
@ -60,7 +60,7 @@ thirdparty_misc_sources = [thirdparty_misc_dir + file for file in thirdparty_mis
|
|||
env_thirdparty.add_source_files(env.core_sources, thirdparty_misc_sources)
|
||||
|
||||
# Zlib library, can be unbundled
|
||||
if env['builtin_zlib']:
|
||||
if env["builtin_zlib"]:
|
||||
thirdparty_zlib_dir = "#thirdparty/zlib/"
|
||||
thirdparty_zlib_sources = [
|
||||
"adler32.c",
|
||||
|
|
@ -80,8 +80,8 @@ if env['builtin_zlib']:
|
|||
env_thirdparty.Prepend(CPPPATH=[thirdparty_zlib_dir])
|
||||
# Needs to be available in main env too
|
||||
env.Prepend(CPPPATH=[thirdparty_zlib_dir])
|
||||
if (env['target'] == 'debug'):
|
||||
env_thirdparty.Append(CPPDEFINES=['ZLIB_DEBUG'])
|
||||
if env["target"] == "debug":
|
||||
env_thirdparty.Append(CPPDEFINES=["ZLIB_DEBUG"])
|
||||
|
||||
env_thirdparty.add_source_files(env.core_sources, thirdparty_zlib_sources)
|
||||
|
||||
|
|
@ -99,7 +99,7 @@ env_thirdparty.add_source_files(env.core_sources, thirdparty_minizip_sources)
|
|||
# Zstd library, can be unbundled in theory
|
||||
# though we currently use some private symbols
|
||||
# https://github.com/godotengine/godot/issues/17374
|
||||
if env['builtin_zstd']:
|
||||
if env["builtin_zstd"]:
|
||||
thirdparty_zstd_dir = "#thirdparty/zstd/"
|
||||
thirdparty_zstd_sources = [
|
||||
"common/debug.c",
|
||||
|
|
@ -142,32 +142,45 @@ if env['builtin_zstd']:
|
|||
env.add_source_files(env.core_sources, "*.cpp")
|
||||
|
||||
# Certificates
|
||||
env.Depends("#core/io/certs_compressed.gen.h", ["#thirdparty/certs/ca-certificates.crt", env.Value(env['builtin_certs']), env.Value(env['system_certs_path'])])
|
||||
env.CommandNoCache("#core/io/certs_compressed.gen.h", "#thirdparty/certs/ca-certificates.crt", run_in_subprocess(core_builders.make_certs_header))
|
||||
env.Depends(
|
||||
"#core/io/certs_compressed.gen.h",
|
||||
["#thirdparty/certs/ca-certificates.crt", env.Value(env["builtin_certs"]), env.Value(env["system_certs_path"])],
|
||||
)
|
||||
env.CommandNoCache(
|
||||
"#core/io/certs_compressed.gen.h",
|
||||
"#thirdparty/certs/ca-certificates.crt",
|
||||
run_in_subprocess(core_builders.make_certs_header),
|
||||
)
|
||||
|
||||
# Make binders
|
||||
env.CommandNoCache(['method_bind.gen.inc', 'method_bind_ext.gen.inc', 'method_bind_free_func.gen.inc'], 'make_binders.py', run_in_subprocess(make_binders.run))
|
||||
env.CommandNoCache(
|
||||
["method_bind.gen.inc", "method_bind_ext.gen.inc", "method_bind_free_func.gen.inc"],
|
||||
"make_binders.py",
|
||||
run_in_subprocess(make_binders.run),
|
||||
)
|
||||
|
||||
# Authors
|
||||
env.Depends('#core/authors.gen.h', "../AUTHORS.md")
|
||||
env.CommandNoCache('#core/authors.gen.h', "../AUTHORS.md", run_in_subprocess(core_builders.make_authors_header))
|
||||
env.Depends("#core/authors.gen.h", "../AUTHORS.md")
|
||||
env.CommandNoCache("#core/authors.gen.h", "../AUTHORS.md", run_in_subprocess(core_builders.make_authors_header))
|
||||
|
||||
# Donors
|
||||
env.Depends('#core/donors.gen.h', "../DONORS.md")
|
||||
env.CommandNoCache('#core/donors.gen.h', "../DONORS.md", run_in_subprocess(core_builders.make_donors_header))
|
||||
env.Depends("#core/donors.gen.h", "../DONORS.md")
|
||||
env.CommandNoCache("#core/donors.gen.h", "../DONORS.md", run_in_subprocess(core_builders.make_donors_header))
|
||||
|
||||
# License
|
||||
env.Depends('#core/license.gen.h', ["../COPYRIGHT.txt", "../LICENSE.txt"])
|
||||
env.CommandNoCache('#core/license.gen.h', ["../COPYRIGHT.txt", "../LICENSE.txt"], run_in_subprocess(core_builders.make_license_header))
|
||||
env.Depends("#core/license.gen.h", ["../COPYRIGHT.txt", "../LICENSE.txt"])
|
||||
env.CommandNoCache(
|
||||
"#core/license.gen.h", ["../COPYRIGHT.txt", "../LICENSE.txt"], run_in_subprocess(core_builders.make_license_header)
|
||||
)
|
||||
|
||||
# Chain load SCsubs
|
||||
SConscript('os/SCsub')
|
||||
SConscript('math/SCsub')
|
||||
SConscript('crypto/SCsub')
|
||||
SConscript('io/SCsub')
|
||||
SConscript('debugger/SCsub')
|
||||
SConscript('input/SCsub')
|
||||
SConscript('bind/SCsub')
|
||||
SConscript("os/SCsub")
|
||||
SConscript("math/SCsub")
|
||||
SConscript("crypto/SCsub")
|
||||
SConscript("io/SCsub")
|
||||
SConscript("debugger/SCsub")
|
||||
SConscript("input/SCsub")
|
||||
SConscript("bind/SCsub")
|
||||
|
||||
|
||||
# Build it all as a library
|
||||
|
|
|
|||
|
|
@ -1,5 +1,5 @@
|
|||
#!/usr/bin/env python
|
||||
|
||||
Import('env')
|
||||
Import("env")
|
||||
|
||||
env.add_source_files(env.core_sources, "*.cpp")
|
||||
|
|
|
|||
|
|
@ -11,15 +11,15 @@ def escape_string(s):
|
|||
rev_result = []
|
||||
while c >= 256:
|
||||
c, low = (c // 256, c % 256)
|
||||
rev_result.append('\\%03o' % low)
|
||||
rev_result.append('\\%03o' % c)
|
||||
return ''.join(reversed(rev_result))
|
||||
rev_result.append("\\%03o" % low)
|
||||
rev_result.append("\\%03o" % c)
|
||||
return "".join(reversed(rev_result))
|
||||
|
||||
result = ''
|
||||
result = ""
|
||||
if isinstance(s, str):
|
||||
s = s.encode('utf-8')
|
||||
s = s.encode("utf-8")
|
||||
for c in s:
|
||||
if not(32 <= c < 127) or c in (ord('\\'), ord('"')):
|
||||
if not (32 <= c < 127) or c in (ord("\\"), ord('"')):
|
||||
result += charcode_to_c_escapes(c)
|
||||
else:
|
||||
result += chr(c)
|
||||
|
|
@ -34,6 +34,7 @@ def make_certs_header(target, source, env):
|
|||
buf = f.read()
|
||||
decomp_size = len(buf)
|
||||
import zlib
|
||||
|
||||
buf = zlib.compress(buf)
|
||||
|
||||
g.write("/* THIS FILE IS GENERATED DO NOT EDIT */\n")
|
||||
|
|
@ -41,9 +42,9 @@ def make_certs_header(target, source, env):
|
|||
g.write("#define CERTS_COMPRESSED_GEN_H\n")
|
||||
|
||||
# System certs path. Editor will use them if defined. (for package maintainers)
|
||||
path = env['system_certs_path']
|
||||
g.write("#define _SYSTEM_CERTS_PATH \"%s\"\n" % str(path))
|
||||
if env['builtin_certs']:
|
||||
path = env["system_certs_path"]
|
||||
g.write('#define _SYSTEM_CERTS_PATH "%s"\n' % str(path))
|
||||
if env["builtin_certs"]:
|
||||
# Defined here and not in env so changing it does not trigger a full rebuild.
|
||||
g.write("#define BUILTIN_CERTS_ENABLED\n")
|
||||
g.write("static const int _certs_compressed_size = " + str(len(buf)) + ";\n")
|
||||
|
|
@ -59,8 +60,18 @@ def make_certs_header(target, source, env):
|
|||
|
||||
|
||||
def make_authors_header(target, source, env):
|
||||
sections = ["Project Founders", "Lead Developer", "Project Manager", "Developers"]
|
||||
sections_id = ["AUTHORS_FOUNDERS", "AUTHORS_LEAD_DEVELOPERS", "AUTHORS_PROJECT_MANAGERS", "AUTHORS_DEVELOPERS"]
|
||||
sections = [
|
||||
"Project Founders",
|
||||
"Lead Developer",
|
||||
"Project Manager",
|
||||
"Developers",
|
||||
]
|
||||
sections_id = [
|
||||
"AUTHORS_FOUNDERS",
|
||||
"AUTHORS_LEAD_DEVELOPERS",
|
||||
"AUTHORS_PROJECT_MANAGERS",
|
||||
"AUTHORS_DEVELOPERS",
|
||||
]
|
||||
|
||||
src = source[0]
|
||||
dst = target[0]
|
||||
|
|
@ -80,7 +91,7 @@ def make_authors_header(target, source, env):
|
|||
for line in f:
|
||||
if reading:
|
||||
if line.startswith(" "):
|
||||
g.write("\t\"" + escape_string(line.strip()) + "\",\n")
|
||||
g.write('\t"' + escape_string(line.strip()) + '",\n')
|
||||
continue
|
||||
if line.startswith("## "):
|
||||
if reading:
|
||||
|
|
@ -103,10 +114,22 @@ def make_authors_header(target, source, env):
|
|||
|
||||
|
||||
def make_donors_header(target, source, env):
|
||||
sections = ["Platinum sponsors", "Gold sponsors", "Mini sponsors",
|
||||
"Gold donors", "Silver donors", "Bronze donors"]
|
||||
sections_id = ["DONORS_SPONSOR_PLAT", "DONORS_SPONSOR_GOLD", "DONORS_SPONSOR_MINI",
|
||||
"DONORS_GOLD", "DONORS_SILVER", "DONORS_BRONZE"]
|
||||
sections = [
|
||||
"Platinum sponsors",
|
||||
"Gold sponsors",
|
||||
"Mini sponsors",
|
||||
"Gold donors",
|
||||
"Silver donors",
|
||||
"Bronze donors",
|
||||
]
|
||||
sections_id = [
|
||||
"DONORS_SPONSOR_PLAT",
|
||||
"DONORS_SPONSOR_GOLD",
|
||||
"DONORS_SPONSOR_MINI",
|
||||
"DONORS_GOLD",
|
||||
"DONORS_SILVER",
|
||||
"DONORS_BRONZE",
|
||||
]
|
||||
|
||||
src = source[0]
|
||||
dst = target[0]
|
||||
|
|
@ -126,7 +149,7 @@ def make_donors_header(target, source, env):
|
|||
for line in f:
|
||||
if reading >= 0:
|
||||
if line.startswith(" "):
|
||||
g.write("\t\"" + escape_string(line.strip()) + "\",\n")
|
||||
g.write('\t"' + escape_string(line.strip()) + '",\n')
|
||||
continue
|
||||
if line.startswith("## "):
|
||||
if reading:
|
||||
|
|
@ -169,8 +192,8 @@ def make_license_header(target, source, env):
|
|||
return line
|
||||
|
||||
def next_tag(self):
|
||||
if not ':' in self.current:
|
||||
return ('', [])
|
||||
if not ":" in self.current:
|
||||
return ("", [])
|
||||
tag, line = self.current.split(":", 1)
|
||||
lines = [line.strip()]
|
||||
while self.next_line() and self.current.startswith(" "):
|
||||
|
|
@ -178,6 +201,7 @@ def make_license_header(target, source, env):
|
|||
return (tag, lines)
|
||||
|
||||
from collections import OrderedDict
|
||||
|
||||
projects = OrderedDict()
|
||||
license_list = []
|
||||
|
||||
|
|
@ -218,26 +242,30 @@ def make_license_header(target, source, env):
|
|||
with open(src_license, "r", encoding="utf-8") as license_file:
|
||||
for line in license_file:
|
||||
escaped_string = escape_string(line.strip())
|
||||
f.write("\n\t\t\"" + escaped_string + "\\n\"")
|
||||
f.write('\n\t\t"' + escaped_string + '\\n"')
|
||||
f.write(";\n\n")
|
||||
|
||||
f.write("struct ComponentCopyrightPart {\n"
|
||||
f.write(
|
||||
"struct ComponentCopyrightPart {\n"
|
||||
"\tconst char *license;\n"
|
||||
"\tconst char *const *files;\n"
|
||||
"\tconst char *const *copyright_statements;\n"
|
||||
"\tint file_count;\n"
|
||||
"\tint copyright_count;\n"
|
||||
"};\n\n")
|
||||
"};\n\n"
|
||||
)
|
||||
|
||||
f.write("struct ComponentCopyright {\n"
|
||||
f.write(
|
||||
"struct ComponentCopyright {\n"
|
||||
"\tconst char *name;\n"
|
||||
"\tconst ComponentCopyrightPart *parts;\n"
|
||||
"\tint part_count;\n"
|
||||
"};\n\n")
|
||||
"};\n\n"
|
||||
)
|
||||
|
||||
f.write("const char *const COPYRIGHT_INFO_DATA[] = {\n")
|
||||
for line in data_list:
|
||||
f.write("\t\"" + escape_string(line) + "\",\n")
|
||||
f.write('\t"' + escape_string(line) + '",\n')
|
||||
f.write("};\n\n")
|
||||
|
||||
f.write("const ComponentCopyrightPart COPYRIGHT_PROJECT_PARTS[] = {\n")
|
||||
|
|
@ -246,11 +274,21 @@ def make_license_header(target, source, env):
|
|||
for project_name, project in iter(projects.items()):
|
||||
part_indexes[project_name] = part_index
|
||||
for part in project:
|
||||
f.write("\t{ \"" + escape_string(part["License"][0]) + "\", "
|
||||
+ "©RIGHT_INFO_DATA[" + str(part["file_index"]) + "], "
|
||||
+ "©RIGHT_INFO_DATA[" + str(part["copyright_index"]) + "], "
|
||||
+ str(len(part["Files"])) + ", "
|
||||
+ str(len(part["Copyright"])) + " },\n")
|
||||
f.write(
|
||||
'\t{ "'
|
||||
+ escape_string(part["License"][0])
|
||||
+ '", '
|
||||
+ "©RIGHT_INFO_DATA["
|
||||
+ str(part["file_index"])
|
||||
+ "], "
|
||||
+ "©RIGHT_INFO_DATA["
|
||||
+ str(part["copyright_index"])
|
||||
+ "], "
|
||||
+ str(len(part["Files"]))
|
||||
+ ", "
|
||||
+ str(len(part["Copyright"]))
|
||||
+ " },\n"
|
||||
)
|
||||
part_index += 1
|
||||
f.write("};\n\n")
|
||||
|
||||
|
|
@ -258,30 +296,37 @@ def make_license_header(target, source, env):
|
|||
|
||||
f.write("const ComponentCopyright COPYRIGHT_INFO[] = {\n")
|
||||
for project_name, project in iter(projects.items()):
|
||||
f.write("\t{ \"" + escape_string(project_name) + "\", "
|
||||
+ "©RIGHT_PROJECT_PARTS[" + str(part_indexes[project_name]) + "], "
|
||||
+ str(len(project)) + " },\n")
|
||||
f.write(
|
||||
'\t{ "'
|
||||
+ escape_string(project_name)
|
||||
+ '", '
|
||||
+ "©RIGHT_PROJECT_PARTS["
|
||||
+ str(part_indexes[project_name])
|
||||
+ "], "
|
||||
+ str(len(project))
|
||||
+ " },\n"
|
||||
)
|
||||
f.write("};\n\n")
|
||||
|
||||
f.write("const int LICENSE_COUNT = " + str(len(license_list)) + ";\n")
|
||||
|
||||
f.write("const char *const LICENSE_NAMES[] = {\n")
|
||||
for l in license_list:
|
||||
f.write("\t\"" + escape_string(l[0]) + "\",\n")
|
||||
f.write('\t"' + escape_string(l[0]) + '",\n')
|
||||
f.write("};\n\n")
|
||||
|
||||
f.write("const char *const LICENSE_BODIES[] = {\n\n")
|
||||
for l in license_list:
|
||||
for line in l[1:]:
|
||||
if line == ".":
|
||||
f.write("\t\"\\n\"\n")
|
||||
f.write('\t"\\n"\n')
|
||||
else:
|
||||
f.write("\t\"" + escape_string(line) + "\\n\"\n")
|
||||
f.write("\t\"\",\n\n")
|
||||
f.write('\t"' + escape_string(line) + '\\n"\n')
|
||||
f.write('\t"",\n\n')
|
||||
f.write("};\n\n")
|
||||
|
||||
f.write("#endif // LICENSE_GEN_H\n")
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
if __name__ == "__main__":
|
||||
subprocess_main(globals())
|
||||
|
|
|
|||
|
|
@ -1,6 +1,6 @@
|
|||
#!/usr/bin/env python
|
||||
|
||||
Import('env')
|
||||
Import("env")
|
||||
|
||||
env_crypto = env.Clone()
|
||||
|
||||
|
|
@ -22,7 +22,9 @@ if not has_module:
|
|||
env_thirdparty = env_crypto.Clone()
|
||||
env_thirdparty.disable_warnings()
|
||||
# Custom config file
|
||||
env_thirdparty.Append(CPPDEFINES=[('MBEDTLS_CONFIG_FILE', '\\"thirdparty/mbedtls/include/godot_core_mbedtls_config.h\\"')])
|
||||
env_thirdparty.Append(
|
||||
CPPDEFINES=[("MBEDTLS_CONFIG_FILE", '\\"thirdparty/mbedtls/include/godot_core_mbedtls_config.h\\"')]
|
||||
)
|
||||
thirdparty_mbedtls_dir = "#thirdparty/mbedtls/library/"
|
||||
thirdparty_mbedtls_sources = [
|
||||
"aes.c",
|
||||
|
|
@ -30,7 +32,7 @@ if not has_module:
|
|||
"md5.c",
|
||||
"sha1.c",
|
||||
"sha256.c",
|
||||
"godot_core_mbedtls_platform.c"
|
||||
"godot_core_mbedtls_platform.c",
|
||||
]
|
||||
thirdparty_mbedtls_sources = [thirdparty_mbedtls_dir + file for file in thirdparty_mbedtls_sources]
|
||||
env_thirdparty.add_source_files(env.core_sources, thirdparty_mbedtls_sources)
|
||||
|
|
|
|||
|
|
@ -1,5 +1,5 @@
|
|||
#!/usr/bin/env python
|
||||
|
||||
Import('env')
|
||||
Import("env")
|
||||
|
||||
env.add_source_files(env.core_sources, "*.cpp")
|
||||
|
|
|
|||
|
|
@ -1,20 +1,28 @@
|
|||
#!/usr/bin/env python
|
||||
|
||||
Import('env')
|
||||
Import("env")
|
||||
|
||||
from platform_methods import run_in_subprocess
|
||||
import input_builders
|
||||
|
||||
|
||||
# Order matters here. Higher index controller database files write on top of lower index database files.
|
||||
controller_databases = ["#core/input/gamecontrollerdb_204.txt", "#core/input/gamecontrollerdb_205.txt", "#core/input/gamecontrollerdb.txt", "#core/input/godotcontrollerdb.txt"]
|
||||
controller_databases = [
|
||||
"#core/input/gamecontrollerdb_204.txt",
|
||||
"#core/input/gamecontrollerdb_205.txt",
|
||||
"#core/input/gamecontrollerdb.txt",
|
||||
"#core/input/godotcontrollerdb.txt",
|
||||
]
|
||||
|
||||
env.Depends("#core/input/default_controller_mappings.gen.cpp", controller_databases)
|
||||
env.CommandNoCache("#core/input/default_controller_mappings.gen.cpp", controller_databases, run_in_subprocess(input_builders.make_default_controller_mappings))
|
||||
env.CommandNoCache(
|
||||
"#core/input/default_controller_mappings.gen.cpp",
|
||||
controller_databases,
|
||||
run_in_subprocess(input_builders.make_default_controller_mappings),
|
||||
)
|
||||
|
||||
env.add_source_files(env.core_sources, "*.cpp")
|
||||
|
||||
# Don't warn about duplicate entry here, we need it registered manually for first build,
|
||||
# even if later builds will pick it up twice due to above *.cpp globbing.
|
||||
env.add_source_files(env.core_sources, "#core/input/default_controller_mappings.gen.cpp", warn_duplicates=False)
|
||||
|
||||
|
|
|
|||
|
|
@ -12,8 +12,8 @@ def make_default_controller_mappings(target, source, env):
|
|||
g = open(dst, "w")
|
||||
|
||||
g.write("/* THIS FILE IS GENERATED DO NOT EDIT */\n")
|
||||
g.write("#include \"core/typedefs.h\"\n")
|
||||
g.write("#include \"core/input/default_controller_mappings.h\"\n")
|
||||
g.write('#include "core/typedefs.h"\n')
|
||||
g.write('#include "core/input/default_controller_mappings.h"\n')
|
||||
|
||||
# ensure mappings have a consistent order
|
||||
platform_mappings = OrderedDict()
|
||||
|
|
@ -37,11 +37,19 @@ def make_default_controller_mappings(target, source, env):
|
|||
line_parts = line.split(",")
|
||||
guid = line_parts[0]
|
||||
if guid in platform_mappings[current_platform]:
|
||||
g.write("// WARNING - DATABASE {} OVERWROTE PRIOR MAPPING: {} {}\n".format(src_path, current_platform, platform_mappings[current_platform][guid]))
|
||||
g.write(
|
||||
"// WARNING - DATABASE {} OVERWROTE PRIOR MAPPING: {} {}\n".format(
|
||||
src_path, current_platform, platform_mappings[current_platform][guid]
|
||||
)
|
||||
)
|
||||
valid_mapping = True
|
||||
for input_map in line_parts[2:]:
|
||||
if "+" in input_map or "-" in input_map or "~" in input_map:
|
||||
g.write("// WARNING - DISCARDED UNSUPPORTED MAPPING TYPE FROM DATABASE {}: {} {}\n".format(src_path, current_platform, line))
|
||||
g.write(
|
||||
"// WARNING - DISCARDED UNSUPPORTED MAPPING TYPE FROM DATABASE {}: {} {}\n".format(
|
||||
src_path, current_platform, line
|
||||
)
|
||||
)
|
||||
valid_mapping = False
|
||||
break
|
||||
if valid_mapping:
|
||||
|
|
@ -62,12 +70,12 @@ def make_default_controller_mappings(target, source, env):
|
|||
variable = platform_variables[platform]
|
||||
g.write("{}\n".format(variable))
|
||||
for mapping in mappings.values():
|
||||
g.write("\t\"{}\",\n".format(mapping))
|
||||
g.write('\t"{}",\n'.format(mapping))
|
||||
g.write("#endif\n")
|
||||
|
||||
g.write("\tNULL\n};\n")
|
||||
g.close()
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
if __name__ == "__main__":
|
||||
subprocess_main(globals())
|
||||
|
|
|
|||
|
|
@ -1,5 +1,5 @@
|
|||
#!/usr/bin/env python
|
||||
|
||||
Import('env')
|
||||
Import("env")
|
||||
|
||||
env.add_source_files(env.core_sources, "*.cpp")
|
||||
|
|
|
|||
|
|
@ -280,58 +280,57 @@ MethodBind* create_method_bind($ifret R$ $ifnoret void$ (*p_method)($ifconst con
|
|||
"""
|
||||
|
||||
|
||||
|
||||
def make_version(template, nargs, argmax, const, ret):
|
||||
|
||||
intext = template
|
||||
from_pos = 0
|
||||
outtext = ""
|
||||
|
||||
while(True):
|
||||
while True:
|
||||
to_pos = intext.find("$", from_pos)
|
||||
if (to_pos == -1):
|
||||
if to_pos == -1:
|
||||
outtext += intext[from_pos:]
|
||||
break
|
||||
else:
|
||||
outtext += intext[from_pos:to_pos]
|
||||
end = intext.find("$", to_pos + 1)
|
||||
if (end == -1):
|
||||
if end == -1:
|
||||
break # ignore
|
||||
macro = intext[to_pos + 1 : end]
|
||||
cmd = ""
|
||||
data = ""
|
||||
|
||||
if (macro.find(" ") != -1):
|
||||
if macro.find(" ") != -1:
|
||||
cmd = macro[0 : macro.find(" ")]
|
||||
data = macro[macro.find(" ") + 1 :]
|
||||
else:
|
||||
cmd = macro
|
||||
|
||||
if (cmd == "argc"):
|
||||
if cmd == "argc":
|
||||
outtext += str(nargs)
|
||||
if (cmd == "ifret" and ret):
|
||||
if cmd == "ifret" and ret:
|
||||
outtext += data
|
||||
if (cmd == "ifargs" and nargs):
|
||||
if cmd == "ifargs" and nargs:
|
||||
outtext += data
|
||||
if (cmd == "ifretargs" and nargs and ret):
|
||||
if cmd == "ifretargs" and nargs and ret:
|
||||
outtext += data
|
||||
if (cmd == "ifconst" and const):
|
||||
if cmd == "ifconst" and const:
|
||||
outtext += data
|
||||
elif (cmd == "ifnoconst" and not const):
|
||||
elif cmd == "ifnoconst" and not const:
|
||||
outtext += data
|
||||
elif (cmd == "ifnoret" and not ret):
|
||||
elif cmd == "ifnoret" and not ret:
|
||||
outtext += data
|
||||
elif (cmd == "iftempl" and (nargs > 0 or ret)):
|
||||
elif cmd == "iftempl" and (nargs > 0 or ret):
|
||||
outtext += data
|
||||
elif (cmd == "arg,"):
|
||||
elif cmd == "arg,":
|
||||
for i in range(1, nargs + 1):
|
||||
if (i > 1):
|
||||
if i > 1:
|
||||
outtext += ", "
|
||||
outtext += data.replace("@", str(i))
|
||||
elif (cmd == "arg"):
|
||||
elif cmd == "arg":
|
||||
for i in range(1, nargs + 1):
|
||||
outtext += data.replace("@", str(i))
|
||||
elif (cmd == "noarg"):
|
||||
elif cmd == "noarg":
|
||||
for i in range(nargs + 1, argmax + 1):
|
||||
outtext += data.replace("@", str(i))
|
||||
|
||||
|
|
@ -348,7 +347,9 @@ def run(target, source, env):
|
|||
text_ext = ""
|
||||
text_free_func = "#ifndef METHOD_BIND_FREE_FUNC_H\n#define METHOD_BIND_FREE_FUNC_H\n"
|
||||
text_free_func += "\n//including this header file allows method binding to use free functions\n"
|
||||
text_free_func += "//note that the free function must have a pointer to an instance of the class as its first parameter\n"
|
||||
text_free_func += (
|
||||
"//note that the free function must have a pointer to an instance of the class as its first parameter\n"
|
||||
)
|
||||
|
||||
for i in range(0, versions + 1):
|
||||
|
||||
|
|
@ -361,7 +362,7 @@ def run(target, source, env):
|
|||
t += make_version(template_typed, i, versions, True, False)
|
||||
t += make_version(template, i, versions, True, True)
|
||||
t += make_version(template_typed, i, versions, True, True)
|
||||
if (i >= versions_ext):
|
||||
if i >= versions_ext:
|
||||
text_ext += t
|
||||
else:
|
||||
text += t
|
||||
|
|
@ -383,6 +384,7 @@ def run(target, source, env):
|
|||
f.write(text_free_func)
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
if __name__ == "__main__":
|
||||
from platform_methods import subprocess_main
|
||||
|
||||
subprocess_main(globals())
|
||||
|
|
|
|||
|
|
@ -1,6 +1,6 @@
|
|||
#!/usr/bin/env python
|
||||
|
||||
Import('env')
|
||||
Import("env")
|
||||
|
||||
env_math = env.Clone()
|
||||
|
||||
|
|
|
|||
|
|
@ -1,5 +1,5 @@
|
|||
#!/usr/bin/env python
|
||||
|
||||
Import('env')
|
||||
Import("env")
|
||||
|
||||
env.add_source_files(env.core_sources, "*.cpp")
|
||||
|
|
|
|||
|
|
@ -21,7 +21,7 @@ def write_string(_f, text, newline=True):
|
|||
for t in range(tab):
|
||||
_f.write("\t")
|
||||
_f.write(text)
|
||||
if (newline):
|
||||
if newline:
|
||||
_f.write("\n")
|
||||
|
||||
|
||||
|
|
@ -30,7 +30,7 @@ def escape(ret):
|
|||
ret = ret.replace("<", ">")
|
||||
ret = ret.replace(">", "<")
|
||||
ret = ret.replace("'", "'")
|
||||
ret = ret.replace("\"", """)
|
||||
ret = ret.replace('"', """)
|
||||
return ret
|
||||
|
||||
|
||||
|
|
@ -43,25 +43,26 @@ def dec_tab():
|
|||
global tab
|
||||
tab -= 1
|
||||
|
||||
|
||||
write_string(f, '<?xml version="1.0" encoding="UTF-8" ?>')
|
||||
write_string(f, '<doc version="' + new_doc.attrib["version"] + '">')
|
||||
|
||||
|
||||
def get_tag(node, name):
|
||||
tag = ""
|
||||
if (name in node.attrib):
|
||||
tag = ' ' + name + '="' + escape(node.attrib[name]) + '" '
|
||||
if name in node.attrib:
|
||||
tag = " " + name + '="' + escape(node.attrib[name]) + '" '
|
||||
return tag
|
||||
|
||||
|
||||
def find_method_descr(old_class, name):
|
||||
|
||||
methods = old_class.find("methods")
|
||||
if(methods != None and len(list(methods)) > 0):
|
||||
if methods != None and len(list(methods)) > 0:
|
||||
for m in list(methods):
|
||||
if (m.attrib["name"] == name):
|
||||
if m.attrib["name"] == name:
|
||||
description = m.find("description")
|
||||
if (description != None and description.text.strip() != ""):
|
||||
if description != None and description.text.strip() != "":
|
||||
return description.text
|
||||
|
||||
return None
|
||||
|
|
@ -70,11 +71,11 @@ def find_method_descr(old_class, name):
|
|||
def find_signal_descr(old_class, name):
|
||||
|
||||
signals = old_class.find("signals")
|
||||
if(signals != None and len(list(signals)) > 0):
|
||||
if signals != None and len(list(signals)) > 0:
|
||||
for m in list(signals):
|
||||
if (m.attrib["name"] == name):
|
||||
if m.attrib["name"] == name:
|
||||
description = m.find("description")
|
||||
if (description != None and description.text.strip() != ""):
|
||||
if description != None and description.text.strip() != "":
|
||||
return description.text
|
||||
|
||||
return None
|
||||
|
|
@ -82,13 +83,13 @@ def find_signal_descr(old_class, name):
|
|||
|
||||
def find_constant_descr(old_class, name):
|
||||
|
||||
if (old_class is None):
|
||||
if old_class is None:
|
||||
return None
|
||||
constants = old_class.find("constants")
|
||||
if(constants != None and len(list(constants)) > 0):
|
||||
if constants != None and len(list(constants)) > 0:
|
||||
for m in list(constants):
|
||||
if (m.attrib["name"] == name):
|
||||
if (m.text.strip() != ""):
|
||||
if m.attrib["name"] == name:
|
||||
if m.text.strip() != "":
|
||||
return m.text
|
||||
return None
|
||||
|
||||
|
|
@ -96,35 +97,35 @@ def find_constant_descr(old_class, name):
|
|||
def write_class(c):
|
||||
class_name = c.attrib["name"]
|
||||
print("Parsing Class: " + class_name)
|
||||
if (class_name in old_classes):
|
||||
if class_name in old_classes:
|
||||
old_class = old_classes[class_name]
|
||||
else:
|
||||
old_class = None
|
||||
|
||||
category = get_tag(c, "category")
|
||||
inherits = get_tag(c, "inherits")
|
||||
write_string(f, '<class name="' + class_name + '" ' + category + inherits + '>')
|
||||
write_string(f, '<class name="' + class_name + '" ' + category + inherits + ">")
|
||||
inc_tab()
|
||||
|
||||
write_string(f, "<brief_description>")
|
||||
|
||||
if (old_class != None):
|
||||
if old_class != None:
|
||||
old_brief_descr = old_class.find("brief_description")
|
||||
if (old_brief_descr != None):
|
||||
if old_brief_descr != None:
|
||||
write_string(f, escape(old_brief_descr.text.strip()))
|
||||
|
||||
write_string(f, "</brief_description>")
|
||||
|
||||
write_string(f, "<description>")
|
||||
if (old_class != None):
|
||||
if old_class != None:
|
||||
old_descr = old_class.find("description")
|
||||
if (old_descr != None):
|
||||
if old_descr != None:
|
||||
write_string(f, escape(old_descr.text.strip()))
|
||||
|
||||
write_string(f, "</description>")
|
||||
|
||||
methods = c.find("methods")
|
||||
if(methods != None and len(list(methods)) > 0):
|
||||
if methods != None and len(list(methods)) > 0:
|
||||
|
||||
write_string(f, "<methods>")
|
||||
inc_tab()
|
||||
|
|
@ -132,35 +133,46 @@ def write_class(c):
|
|||
for m in list(methods):
|
||||
qualifiers = get_tag(m, "qualifiers")
|
||||
|
||||
write_string(f, '<method name="' + escape(m.attrib["name"]) + '" ' + qualifiers + '>')
|
||||
write_string(f, '<method name="' + escape(m.attrib["name"]) + '" ' + qualifiers + ">")
|
||||
inc_tab()
|
||||
|
||||
for a in list(m):
|
||||
if (a.tag == "return"):
|
||||
if a.tag == "return":
|
||||
typ = get_tag(a, "type")
|
||||
write_string(f, '<return' + typ + '>')
|
||||
write_string(f, '</return>')
|
||||
elif (a.tag == "argument"):
|
||||
write_string(f, "<return" + typ + ">")
|
||||
write_string(f, "</return>")
|
||||
elif a.tag == "argument":
|
||||
|
||||
default = get_tag(a, "default")
|
||||
|
||||
write_string(f, '<argument index="' + a.attrib["index"] + '" name="' + escape(a.attrib["name"]) + '" type="' + a.attrib["type"] + '"' + default + '>')
|
||||
write_string(f, '</argument>')
|
||||
write_string(
|
||||
f,
|
||||
'<argument index="'
|
||||
+ a.attrib["index"]
|
||||
+ '" name="'
|
||||
+ escape(a.attrib["name"])
|
||||
+ '" type="'
|
||||
+ a.attrib["type"]
|
||||
+ '"'
|
||||
+ default
|
||||
+ ">",
|
||||
)
|
||||
write_string(f, "</argument>")
|
||||
|
||||
write_string(f, '<description>')
|
||||
if (old_class != None):
|
||||
write_string(f, "<description>")
|
||||
if old_class != None:
|
||||
old_method_descr = find_method_descr(old_class, m.attrib["name"])
|
||||
if (old_method_descr):
|
||||
if old_method_descr:
|
||||
write_string(f, escape(escape(old_method_descr.strip())))
|
||||
|
||||
write_string(f, '</description>')
|
||||
write_string(f, "</description>")
|
||||
dec_tab()
|
||||
write_string(f, "</method>")
|
||||
dec_tab()
|
||||
write_string(f, "</methods>")
|
||||
|
||||
signals = c.find("signals")
|
||||
if(signals != None and len(list(signals)) > 0):
|
||||
if signals != None and len(list(signals)) > 0:
|
||||
|
||||
write_string(f, "<signals>")
|
||||
inc_tab()
|
||||
|
|
@ -171,24 +183,33 @@ def write_class(c):
|
|||
inc_tab()
|
||||
|
||||
for a in list(m):
|
||||
if (a.tag == "argument"):
|
||||
if a.tag == "argument":
|
||||
|
||||
write_string(f, '<argument index="' + a.attrib["index"] + '" name="' + escape(a.attrib["name"]) + '" type="' + a.attrib["type"] + '">')
|
||||
write_string(f, '</argument>')
|
||||
write_string(
|
||||
f,
|
||||
'<argument index="'
|
||||
+ a.attrib["index"]
|
||||
+ '" name="'
|
||||
+ escape(a.attrib["name"])
|
||||
+ '" type="'
|
||||
+ a.attrib["type"]
|
||||
+ '">',
|
||||
)
|
||||
write_string(f, "</argument>")
|
||||
|
||||
write_string(f, '<description>')
|
||||
if (old_class != None):
|
||||
write_string(f, "<description>")
|
||||
if old_class != None:
|
||||
old_signal_descr = find_signal_descr(old_class, m.attrib["name"])
|
||||
if (old_signal_descr):
|
||||
if old_signal_descr:
|
||||
write_string(f, escape(old_signal_descr.strip()))
|
||||
write_string(f, '</description>')
|
||||
write_string(f, "</description>")
|
||||
dec_tab()
|
||||
write_string(f, "</signal>")
|
||||
dec_tab()
|
||||
write_string(f, "</signals>")
|
||||
|
||||
constants = c.find("constants")
|
||||
if(constants != None and len(list(constants)) > 0):
|
||||
if constants != None and len(list(constants)) > 0:
|
||||
|
||||
write_string(f, "<constants>")
|
||||
inc_tab()
|
||||
|
|
@ -197,7 +218,7 @@ def write_class(c):
|
|||
|
||||
write_string(f, '<constant name="' + escape(m.attrib["name"]) + '" value="' + m.attrib["value"] + '">')
|
||||
old_constant_descr = find_constant_descr(old_class, m.attrib["name"])
|
||||
if (old_constant_descr):
|
||||
if old_constant_descr:
|
||||
write_string(f, escape(old_constant_descr.strip()))
|
||||
write_string(f, "</constant>")
|
||||
|
||||
|
|
@ -207,9 +228,10 @@ def write_class(c):
|
|||
dec_tab()
|
||||
write_string(f, "</class>")
|
||||
|
||||
|
||||
for c in list(old_doc):
|
||||
old_classes[c.attrib["name"]] = c
|
||||
|
||||
for c in list(new_doc):
|
||||
write_class(c)
|
||||
write_string(f, '</doc>\n')
|
||||
write_string(f, "</doc>\n")
|
||||
|
|
|
|||
|
|
@ -13,75 +13,74 @@ import xml.etree.ElementTree as ET
|
|||
################################################################################
|
||||
|
||||
flags = {
|
||||
'c': platform.platform() != 'Windows', # Disable by default on windows, since we use ANSI escape codes
|
||||
'b': False,
|
||||
'g': False,
|
||||
's': False,
|
||||
'u': False,
|
||||
'h': False,
|
||||
'p': False,
|
||||
'o': True,
|
||||
'i': False,
|
||||
'a': True,
|
||||
'e': False,
|
||||
"c": platform.platform() != "Windows", # Disable by default on windows, since we use ANSI escape codes
|
||||
"b": False,
|
||||
"g": False,
|
||||
"s": False,
|
||||
"u": False,
|
||||
"h": False,
|
||||
"p": False,
|
||||
"o": True,
|
||||
"i": False,
|
||||
"a": True,
|
||||
"e": False,
|
||||
}
|
||||
flag_descriptions = {
|
||||
'c': 'Toggle colors when outputting.',
|
||||
'b': 'Toggle showing only not fully described classes.',
|
||||
'g': 'Toggle showing only completed classes.',
|
||||
's': 'Toggle showing comments about the status.',
|
||||
'u': 'Toggle URLs to docs.',
|
||||
'h': 'Show help and exit.',
|
||||
'p': 'Toggle showing percentage as well as counts.',
|
||||
'o': 'Toggle overall column.',
|
||||
'i': 'Toggle collapse of class items columns.',
|
||||
'a': 'Toggle showing all items.',
|
||||
'e': 'Toggle hiding empty items.',
|
||||
"c": "Toggle colors when outputting.",
|
||||
"b": "Toggle showing only not fully described classes.",
|
||||
"g": "Toggle showing only completed classes.",
|
||||
"s": "Toggle showing comments about the status.",
|
||||
"u": "Toggle URLs to docs.",
|
||||
"h": "Show help and exit.",
|
||||
"p": "Toggle showing percentage as well as counts.",
|
||||
"o": "Toggle overall column.",
|
||||
"i": "Toggle collapse of class items columns.",
|
||||
"a": "Toggle showing all items.",
|
||||
"e": "Toggle hiding empty items.",
|
||||
}
|
||||
long_flags = {
|
||||
'colors': 'c',
|
||||
'use-colors': 'c',
|
||||
|
||||
'bad': 'b',
|
||||
'only-bad': 'b',
|
||||
|
||||
'good': 'g',
|
||||
'only-good': 'g',
|
||||
|
||||
'comments': 's',
|
||||
'status': 's',
|
||||
|
||||
'urls': 'u',
|
||||
'gen-url': 'u',
|
||||
|
||||
'help': 'h',
|
||||
|
||||
'percent': 'p',
|
||||
'use-percentages': 'p',
|
||||
|
||||
'overall': 'o',
|
||||
'use-overall': 'o',
|
||||
|
||||
'items': 'i',
|
||||
'collapse': 'i',
|
||||
|
||||
'all': 'a',
|
||||
|
||||
'empty': 'e',
|
||||
"colors": "c",
|
||||
"use-colors": "c",
|
||||
"bad": "b",
|
||||
"only-bad": "b",
|
||||
"good": "g",
|
||||
"only-good": "g",
|
||||
"comments": "s",
|
||||
"status": "s",
|
||||
"urls": "u",
|
||||
"gen-url": "u",
|
||||
"help": "h",
|
||||
"percent": "p",
|
||||
"use-percentages": "p",
|
||||
"overall": "o",
|
||||
"use-overall": "o",
|
||||
"items": "i",
|
||||
"collapse": "i",
|
||||
"all": "a",
|
||||
"empty": "e",
|
||||
}
|
||||
table_columns = ['name', 'brief_description', 'description', 'methods', 'constants', 'members', 'signals', 'theme_items']
|
||||
table_column_names = ['Name', 'Brief Desc.', 'Desc.', 'Methods', 'Constants', 'Members', 'Signals', 'Theme Items']
|
||||
table_columns = [
|
||||
"name",
|
||||
"brief_description",
|
||||
"description",
|
||||
"methods",
|
||||
"constants",
|
||||
"members",
|
||||
"signals",
|
||||
"theme_items",
|
||||
]
|
||||
table_column_names = ["Name", "Brief Desc.", "Desc.", "Methods", "Constants", "Members", "Signals", "Theme Items"]
|
||||
colors = {
|
||||
'name': [36], # cyan
|
||||
'part_big_problem': [4, 31], # underline, red
|
||||
'part_problem': [31], # red
|
||||
'part_mostly_good': [33], # yellow
|
||||
'part_good': [32], # green
|
||||
'url': [4, 34], # underline, blue
|
||||
'section': [1, 4], # bold, underline
|
||||
'state_off': [36], # cyan
|
||||
'state_on': [1, 35], # bold, magenta/plum
|
||||
'bold': [1], # bold
|
||||
"name": [36], # cyan
|
||||
"part_big_problem": [4, 31], # underline, red
|
||||
"part_problem": [31], # red
|
||||
"part_mostly_good": [33], # yellow
|
||||
"part_good": [32], # green
|
||||
"url": [4, 34], # underline, blue
|
||||
"section": [1, 4], # bold, underline
|
||||
"state_off": [36], # cyan
|
||||
"state_on": [1, 35], # bold, magenta/plum
|
||||
"bold": [1], # bold
|
||||
}
|
||||
overall_progress_description_weigth = 10
|
||||
|
||||
|
|
@ -90,6 +89,7 @@ overall_progress_description_weigth = 10
|
|||
# Utils #
|
||||
################################################################################
|
||||
|
||||
|
||||
def validate_tag(elem, tag):
|
||||
if elem.tag != tag:
|
||||
print('Tag mismatch, expected "' + tag + '", got ' + elem.tag)
|
||||
|
|
@ -97,36 +97,38 @@ def validate_tag(elem, tag):
|
|||
|
||||
|
||||
def color(color, string):
|
||||
if flags['c'] and terminal_supports_color():
|
||||
color_format = ''
|
||||
if flags["c"] and terminal_supports_color():
|
||||
color_format = ""
|
||||
for code in colors[color]:
|
||||
color_format += '\033[' + str(code) + 'm'
|
||||
return color_format + string + '\033[0m'
|
||||
color_format += "\033[" + str(code) + "m"
|
||||
return color_format + string + "\033[0m"
|
||||
else:
|
||||
return string
|
||||
|
||||
ansi_escape = re.compile(r'\x1b[^m]*m')
|
||||
|
||||
ansi_escape = re.compile(r"\x1b[^m]*m")
|
||||
|
||||
|
||||
def nonescape_len(s):
|
||||
return len(ansi_escape.sub('', s))
|
||||
return len(ansi_escape.sub("", s))
|
||||
|
||||
|
||||
def terminal_supports_color():
|
||||
p = sys.platform
|
||||
supported_platform = p != 'Pocket PC' and (p != 'win32' or
|
||||
'ANSICON' in os.environ)
|
||||
supported_platform = p != "Pocket PC" and (p != "win32" or "ANSICON" in os.environ)
|
||||
|
||||
is_a_tty = hasattr(sys.stdout, 'isatty') and sys.stdout.isatty()
|
||||
is_a_tty = hasattr(sys.stdout, "isatty") and sys.stdout.isatty()
|
||||
if not supported_platform or not is_a_tty:
|
||||
return False
|
||||
return True
|
||||
|
||||
|
||||
################################################################################
|
||||
# Classes #
|
||||
################################################################################
|
||||
|
||||
class ClassStatusProgress:
|
||||
|
||||
class ClassStatusProgress:
|
||||
def __init__(self, described=0, total=0):
|
||||
self.described = described
|
||||
self.total = total
|
||||
|
|
@ -143,42 +145,41 @@ class ClassStatusProgress:
|
|||
return self.described >= self.total
|
||||
|
||||
def to_configured_colored_string(self):
|
||||
if flags['p']:
|
||||
return self.to_colored_string('{percent}% ({has}/{total})', '{pad_percent}{pad_described}{s}{pad_total}')
|
||||
if flags["p"]:
|
||||
return self.to_colored_string("{percent}% ({has}/{total})", "{pad_percent}{pad_described}{s}{pad_total}")
|
||||
else:
|
||||
return self.to_colored_string()
|
||||
|
||||
def to_colored_string(self, format='{has}/{total}', pad_format='{pad_described}{s}{pad_total}'):
|
||||
def to_colored_string(self, format="{has}/{total}", pad_format="{pad_described}{s}{pad_total}"):
|
||||
ratio = float(self.described) / float(self.total) if self.total != 0 else 1
|
||||
percent = int(round(100 * ratio))
|
||||
s = format.format(has=str(self.described), total=str(self.total), percent=str(percent))
|
||||
if self.described >= self.total:
|
||||
s = color('part_good', s)
|
||||
s = color("part_good", s)
|
||||
elif self.described >= self.total / 4 * 3:
|
||||
s = color('part_mostly_good', s)
|
||||
s = color("part_mostly_good", s)
|
||||
elif self.described > 0:
|
||||
s = color('part_problem', s)
|
||||
s = color("part_problem", s)
|
||||
else:
|
||||
s = color('part_big_problem', s)
|
||||
s = color("part_big_problem", s)
|
||||
pad_size = max(len(str(self.described)), len(str(self.total)))
|
||||
pad_described = ''.ljust(pad_size - len(str(self.described)))
|
||||
pad_percent = ''.ljust(3 - len(str(percent)))
|
||||
pad_total = ''.ljust(pad_size - len(str(self.total)))
|
||||
pad_described = "".ljust(pad_size - len(str(self.described)))
|
||||
pad_percent = "".ljust(3 - len(str(percent)))
|
||||
pad_total = "".ljust(pad_size - len(str(self.total)))
|
||||
return pad_format.format(pad_described=pad_described, pad_total=pad_total, pad_percent=pad_percent, s=s)
|
||||
|
||||
|
||||
class ClassStatus:
|
||||
|
||||
def __init__(self, name=''):
|
||||
def __init__(self, name=""):
|
||||
self.name = name
|
||||
self.has_brief_description = True
|
||||
self.has_description = True
|
||||
self.progresses = {
|
||||
'methods': ClassStatusProgress(),
|
||||
'constants': ClassStatusProgress(),
|
||||
'members': ClassStatusProgress(),
|
||||
'theme_items': ClassStatusProgress(),
|
||||
'signals': ClassStatusProgress()
|
||||
"methods": ClassStatusProgress(),
|
||||
"constants": ClassStatusProgress(),
|
||||
"members": ClassStatusProgress(),
|
||||
"theme_items": ClassStatusProgress(),
|
||||
"signals": ClassStatusProgress(),
|
||||
}
|
||||
|
||||
def __add__(self, other):
|
||||
|
|
@ -208,66 +209,70 @@ class ClassStatus:
|
|||
|
||||
def make_output(self):
|
||||
output = {}
|
||||
output['name'] = color('name', self.name)
|
||||
output["name"] = color("name", self.name)
|
||||
|
||||
ok_string = color('part_good', 'OK')
|
||||
missing_string = color('part_big_problem', 'MISSING')
|
||||
ok_string = color("part_good", "OK")
|
||||
missing_string = color("part_big_problem", "MISSING")
|
||||
|
||||
output['brief_description'] = ok_string if self.has_brief_description else missing_string
|
||||
output['description'] = ok_string if self.has_description else missing_string
|
||||
output["brief_description"] = ok_string if self.has_brief_description else missing_string
|
||||
output["description"] = ok_string if self.has_description else missing_string
|
||||
|
||||
description_progress = ClassStatusProgress(
|
||||
(self.has_brief_description + self.has_description) * overall_progress_description_weigth,
|
||||
2 * overall_progress_description_weigth
|
||||
2 * overall_progress_description_weigth,
|
||||
)
|
||||
items_progress = ClassStatusProgress()
|
||||
|
||||
for k in ['methods', 'constants', 'members', 'signals', 'theme_items']:
|
||||
for k in ["methods", "constants", "members", "signals", "theme_items"]:
|
||||
items_progress += self.progresses[k]
|
||||
output[k] = self.progresses[k].to_configured_colored_string()
|
||||
|
||||
output['items'] = items_progress.to_configured_colored_string()
|
||||
output["items"] = items_progress.to_configured_colored_string()
|
||||
|
||||
output['overall'] = (description_progress + items_progress).to_colored_string(color('bold', '{percent}%'), '{pad_percent}{s}')
|
||||
output["overall"] = (description_progress + items_progress).to_colored_string(
|
||||
color("bold", "{percent}%"), "{pad_percent}{s}"
|
||||
)
|
||||
|
||||
if self.name.startswith('Total'):
|
||||
output['url'] = color('url', 'https://docs.godotengine.org/en/latest/classes/')
|
||||
if flags['s']:
|
||||
output['comment'] = color('part_good', 'ALL OK')
|
||||
if self.name.startswith("Total"):
|
||||
output["url"] = color("url", "https://docs.godotengine.org/en/latest/classes/")
|
||||
if flags["s"]:
|
||||
output["comment"] = color("part_good", "ALL OK")
|
||||
else:
|
||||
output['url'] = color('url', 'https://docs.godotengine.org/en/latest/classes/class_{name}.html'.format(name=self.name.lower()))
|
||||
output["url"] = color(
|
||||
"url", "https://docs.godotengine.org/en/latest/classes/class_{name}.html".format(name=self.name.lower())
|
||||
)
|
||||
|
||||
if flags['s'] and not flags['g'] and self.is_ok():
|
||||
output['comment'] = color('part_good', 'ALL OK')
|
||||
if flags["s"] and not flags["g"] and self.is_ok():
|
||||
output["comment"] = color("part_good", "ALL OK")
|
||||
|
||||
return output
|
||||
|
||||
@staticmethod
|
||||
def generate_for_class(c):
|
||||
status = ClassStatus()
|
||||
status.name = c.attrib['name']
|
||||
status.name = c.attrib["name"]
|
||||
|
||||
for tag in list(c):
|
||||
|
||||
if tag.tag == 'brief_description':
|
||||
if tag.tag == "brief_description":
|
||||
status.has_brief_description = len(tag.text.strip()) > 0
|
||||
|
||||
elif tag.tag == 'description':
|
||||
elif tag.tag == "description":
|
||||
status.has_description = len(tag.text.strip()) > 0
|
||||
|
||||
elif tag.tag in ['methods', 'signals']:
|
||||
elif tag.tag in ["methods", "signals"]:
|
||||
for sub_tag in list(tag):
|
||||
descr = sub_tag.find('description')
|
||||
descr = sub_tag.find("description")
|
||||
status.progresses[tag.tag].increment(len(descr.text.strip()) > 0)
|
||||
elif tag.tag in ['constants', 'members', 'theme_items']:
|
||||
elif tag.tag in ["constants", "members", "theme_items"]:
|
||||
for sub_tag in list(tag):
|
||||
if not sub_tag.text is None:
|
||||
status.progresses[tag.tag].increment(len(sub_tag.text.strip()) > 0)
|
||||
|
||||
elif tag.tag in ['tutorials']:
|
||||
elif tag.tag in ["tutorials"]:
|
||||
pass # Ignore those tags for now
|
||||
|
||||
elif tag.tag in ['theme_items']:
|
||||
elif tag.tag in ["theme_items"]:
|
||||
pass # Ignore those tags, since they seem to lack description at all
|
||||
|
||||
else:
|
||||
|
|
@ -286,63 +291,69 @@ merged_file = ""
|
|||
|
||||
for arg in sys.argv[1:]:
|
||||
try:
|
||||
if arg.startswith('--'):
|
||||
if arg.startswith("--"):
|
||||
flags[long_flags[arg[2:]]] = not flags[long_flags[arg[2:]]]
|
||||
elif arg.startswith('-'):
|
||||
elif arg.startswith("-"):
|
||||
for f in arg[1:]:
|
||||
flags[f] = not flags[f]
|
||||
elif os.path.isdir(arg):
|
||||
for f in os.listdir(arg):
|
||||
if f.endswith('.xml'):
|
||||
input_file_list.append(os.path.join(arg, f));
|
||||
if f.endswith(".xml"):
|
||||
input_file_list.append(os.path.join(arg, f))
|
||||
else:
|
||||
input_class_list.append(arg)
|
||||
except KeyError:
|
||||
print("Unknown command line flag: " + arg)
|
||||
sys.exit(1)
|
||||
|
||||
if flags['i']:
|
||||
for r in ['methods', 'constants', 'members', 'signals', 'theme_items']:
|
||||
if flags["i"]:
|
||||
for r in ["methods", "constants", "members", "signals", "theme_items"]:
|
||||
index = table_columns.index(r)
|
||||
del table_column_names[index]
|
||||
del table_columns[index]
|
||||
table_column_names.append('Items')
|
||||
table_columns.append('items')
|
||||
table_column_names.append("Items")
|
||||
table_columns.append("items")
|
||||
|
||||
if flags['o'] == (not flags['i']):
|
||||
table_column_names.append(color('bold', 'Overall'))
|
||||
table_columns.append('overall')
|
||||
if flags["o"] == (not flags["i"]):
|
||||
table_column_names.append(color("bold", "Overall"))
|
||||
table_columns.append("overall")
|
||||
|
||||
if flags['u']:
|
||||
table_column_names.append('Docs URL')
|
||||
table_columns.append('url')
|
||||
if flags["u"]:
|
||||
table_column_names.append("Docs URL")
|
||||
table_columns.append("url")
|
||||
|
||||
|
||||
################################################################################
|
||||
# Help #
|
||||
################################################################################
|
||||
|
||||
if len(input_file_list) < 1 or flags['h']:
|
||||
if not flags['h']:
|
||||
print(color('section', 'Invalid usage') + ': Please specify a classes directory')
|
||||
print(color('section', 'Usage') + ': doc_status.py [flags] <classes_dir> [class names]')
|
||||
print('\t< and > signify required parameters, while [ and ] signify optional parameters.')
|
||||
print(color('section', 'Available flags') + ':')
|
||||
if len(input_file_list) < 1 or flags["h"]:
|
||||
if not flags["h"]:
|
||||
print(color("section", "Invalid usage") + ": Please specify a classes directory")
|
||||
print(color("section", "Usage") + ": doc_status.py [flags] <classes_dir> [class names]")
|
||||
print("\t< and > signify required parameters, while [ and ] signify optional parameters.")
|
||||
print(color("section", "Available flags") + ":")
|
||||
possible_synonym_list = list(long_flags)
|
||||
possible_synonym_list.sort()
|
||||
flag_list = list(flags)
|
||||
flag_list.sort()
|
||||
for flag in flag_list:
|
||||
synonyms = [color('name', '-' + flag)]
|
||||
synonyms = [color("name", "-" + flag)]
|
||||
for synonym in possible_synonym_list:
|
||||
if long_flags[synonym] == flag:
|
||||
synonyms.append(color('name', '--' + synonym))
|
||||
synonyms.append(color("name", "--" + synonym))
|
||||
|
||||
print(('{synonyms} (Currently ' + color('state_' + ('on' if flags[flag] else 'off'), '{value}') + ')\n\t{description}').format(
|
||||
synonyms=', '.join(synonyms),
|
||||
value=('on' if flags[flag] else 'off'),
|
||||
description=flag_descriptions[flag]
|
||||
))
|
||||
print(
|
||||
(
|
||||
"{synonyms} (Currently "
|
||||
+ color("state_" + ("on" if flags[flag] else "off"), "{value}")
|
||||
+ ")\n\t{description}"
|
||||
).format(
|
||||
synonyms=", ".join(synonyms),
|
||||
value=("on" if flags[flag] else "off"),
|
||||
description=flag_descriptions[flag],
|
||||
)
|
||||
)
|
||||
sys.exit(0)
|
||||
|
||||
|
||||
|
|
@ -357,21 +368,21 @@ for file in input_file_list:
|
|||
tree = ET.parse(file)
|
||||
doc = tree.getroot()
|
||||
|
||||
if 'version' not in doc.attrib:
|
||||
if "version" not in doc.attrib:
|
||||
print('Version missing from "doc"')
|
||||
sys.exit(255)
|
||||
|
||||
version = doc.attrib['version']
|
||||
version = doc.attrib["version"]
|
||||
|
||||
if doc.attrib['name'] in class_names:
|
||||
if doc.attrib["name"] in class_names:
|
||||
continue
|
||||
class_names.append(doc.attrib['name'])
|
||||
classes[doc.attrib['name']] = doc
|
||||
class_names.append(doc.attrib["name"])
|
||||
classes[doc.attrib["name"]] = doc
|
||||
|
||||
class_names.sort()
|
||||
|
||||
if len(input_class_list) < 1:
|
||||
input_class_list = ['*']
|
||||
input_class_list = ["*"]
|
||||
|
||||
filtered_classes = set()
|
||||
for pattern in input_class_list:
|
||||
|
|
@ -384,23 +395,23 @@ filtered_classes.sort()
|
|||
################################################################################
|
||||
|
||||
table = [table_column_names]
|
||||
table_row_chars = '| - '
|
||||
table_column_chars = '|'
|
||||
table_row_chars = "| - "
|
||||
table_column_chars = "|"
|
||||
|
||||
total_status = ClassStatus('Total')
|
||||
total_status = ClassStatus("Total")
|
||||
|
||||
for cn in filtered_classes:
|
||||
|
||||
c = classes[cn]
|
||||
validate_tag(c, 'class')
|
||||
validate_tag(c, "class")
|
||||
status = ClassStatus.generate_for_class(c)
|
||||
|
||||
total_status = total_status + status
|
||||
|
||||
if (flags['b'] and status.is_ok()) or (flags['g'] and not status.is_ok()) or (not flags['a']):
|
||||
if (flags["b"] and status.is_ok()) or (flags["g"] and not status.is_ok()) or (not flags["a"]):
|
||||
continue
|
||||
|
||||
if flags['e'] and status.is_empty():
|
||||
if flags["e"] and status.is_empty():
|
||||
continue
|
||||
|
||||
out = status.make_output()
|
||||
|
|
@ -409,10 +420,10 @@ for cn in filtered_classes:
|
|||
if column in out:
|
||||
row.append(out[column])
|
||||
else:
|
||||
row.append('')
|
||||
row.append("")
|
||||
|
||||
if 'comment' in out and out['comment'] != '':
|
||||
row.append(out['comment'])
|
||||
if "comment" in out and out["comment"] != "":
|
||||
row.append(out["comment"])
|
||||
|
||||
table.append(row)
|
||||
|
||||
|
|
@ -421,22 +432,22 @@ for cn in filtered_classes:
|
|||
# Print output table #
|
||||
################################################################################
|
||||
|
||||
if len(table) == 1 and flags['a']:
|
||||
print(color('part_big_problem', 'No classes suitable for printing!'))
|
||||
if len(table) == 1 and flags["a"]:
|
||||
print(color("part_big_problem", "No classes suitable for printing!"))
|
||||
sys.exit(0)
|
||||
|
||||
if len(table) > 2 or not flags['a']:
|
||||
total_status.name = 'Total = {0}'.format(len(table) - 1)
|
||||
if len(table) > 2 or not flags["a"]:
|
||||
total_status.name = "Total = {0}".format(len(table) - 1)
|
||||
out = total_status.make_output()
|
||||
row = []
|
||||
for column in table_columns:
|
||||
if column in out:
|
||||
row.append(out[column])
|
||||
else:
|
||||
row.append('')
|
||||
row.append("")
|
||||
table.append(row)
|
||||
|
||||
if flags['a']:
|
||||
if flags["a"]:
|
||||
# Duplicate the headers at the bottom of the table so they can be viewed
|
||||
# without having to scroll back to the top.
|
||||
table.append(table_column_names)
|
||||
|
|
@ -451,7 +462,9 @@ for row in table:
|
|||
|
||||
divider_string = table_row_chars[0]
|
||||
for cell_i in range(len(table[0])):
|
||||
divider_string += table_row_chars[1] + table_row_chars[2] * (table_column_sizes[cell_i]) + table_row_chars[1] + table_row_chars[0]
|
||||
divider_string += (
|
||||
table_row_chars[1] + table_row_chars[2] * (table_column_sizes[cell_i]) + table_row_chars[1] + table_row_chars[0]
|
||||
)
|
||||
print(divider_string)
|
||||
|
||||
for row_i, row in enumerate(table):
|
||||
|
|
@ -461,7 +474,11 @@ for row_i, row in enumerate(table):
|
|||
if cell_i == 0:
|
||||
row_string += table_row_chars[3] + cell + table_row_chars[3] * (padding_needed - 1)
|
||||
else:
|
||||
row_string += table_row_chars[3] * int(math.floor(float(padding_needed) / 2)) + cell + table_row_chars[3] * int(math.ceil(float(padding_needed) / 2))
|
||||
row_string += (
|
||||
table_row_chars[3] * int(math.floor(float(padding_needed) / 2))
|
||||
+ cell
|
||||
+ table_row_chars[3] * int(math.ceil(float(padding_needed) / 2))
|
||||
)
|
||||
row_string += table_column_chars
|
||||
|
||||
print(row_string)
|
||||
|
|
@ -474,5 +491,5 @@ for row_i, row in enumerate(table):
|
|||
|
||||
print(divider_string)
|
||||
|
||||
if total_status.is_ok() and not flags['g']:
|
||||
print('All listed classes are ' + color('part_good', 'OK') + '!')
|
||||
if total_status.is_ok() and not flags["g"]:
|
||||
print("All listed classes are " + color("part_good", "OK") + "!")
|
||||
|
|
|
|||
|
|
@ -10,7 +10,9 @@ from collections import OrderedDict
|
|||
# from typing import List, Dict, TextIO, Tuple, Iterable, Optional, DefaultDict, Any, Union
|
||||
|
||||
# http(s)://docs.godotengine.org/<langcode>/<tag>/path/to/page.html(#fragment-tag)
|
||||
GODOT_DOCS_PATTERN = re.compile(r'^http(?:s)?://docs\.godotengine\.org/(?:[a-zA-Z0-9.\-_]*)/(?:[a-zA-Z0-9.\-_]*)/(.*)\.html(#.*)?$')
|
||||
GODOT_DOCS_PATTERN = re.compile(
|
||||
r"^http(?:s)?://docs\.godotengine\.org/(?:[a-zA-Z0-9.\-_]*)/(?:[a-zA-Z0-9.\-_]*)/(.*)\.html(#.*)?$"
|
||||
)
|
||||
|
||||
|
||||
def print_error(error, state): # type: (str, State) -> None
|
||||
|
|
@ -37,7 +39,9 @@ class TypeName:
|
|||
|
||||
|
||||
class PropertyDef:
|
||||
def __init__(self, name, type_name, setter, getter, text, default_value, overridden): # type: (str, TypeName, Optional[str], Optional[str], Optional[str], Optional[str], Optional[bool]) -> None
|
||||
def __init__(
|
||||
self, name, type_name, setter, getter, text, default_value, overridden
|
||||
): # type: (str, TypeName, Optional[str], Optional[str], Optional[str], Optional[str], Optional[bool]) -> None
|
||||
self.name = name
|
||||
self.type_name = type_name
|
||||
self.setter = setter
|
||||
|
|
@ -46,6 +50,7 @@ class PropertyDef:
|
|||
self.default_value = default_value
|
||||
self.overridden = overridden
|
||||
|
||||
|
||||
class ParameterDef:
|
||||
def __init__(self, name, type_name, default_value): # type: (str, TypeName, Optional[str]) -> None
|
||||
self.name = name
|
||||
|
|
@ -61,7 +66,9 @@ class SignalDef:
|
|||
|
||||
|
||||
class MethodDef:
|
||||
def __init__(self, name, return_type, parameters, description, qualifiers): # type: (str, TypeName, List[ParameterDef], Optional[str], Optional[str]) -> None
|
||||
def __init__(
|
||||
self, name, return_type, parameters, description, qualifiers
|
||||
): # type: (str, TypeName, List[ParameterDef], Optional[str], Optional[str]) -> None
|
||||
self.name = name
|
||||
self.return_type = return_type
|
||||
self.parameters = parameters
|
||||
|
|
@ -144,10 +151,12 @@ class State:
|
|||
getter = property.get("getter") or None
|
||||
default_value = property.get("default") or None
|
||||
if default_value is not None:
|
||||
default_value = '``{}``'.format(default_value)
|
||||
default_value = "``{}``".format(default_value)
|
||||
overridden = property.get("override") or False
|
||||
|
||||
property_def = PropertyDef(property_name, type_name, setter, getter, property.text, default_value, overridden)
|
||||
property_def = PropertyDef(
|
||||
property_name, type_name, setter, getter, property.text, default_value, overridden
|
||||
)
|
||||
class_def.properties[property_name] = property_def
|
||||
|
||||
methods = class_root.find("methods")
|
||||
|
|
@ -246,8 +255,6 @@ class State:
|
|||
if link.text is not None:
|
||||
class_def.tutorials.append(link.text)
|
||||
|
||||
|
||||
|
||||
def sort_classes(self): # type: () -> None
|
||||
self.classes = OrderedDict(sorted(self.classes.items(), key=lambda t: t[0]))
|
||||
|
||||
|
|
@ -273,7 +280,11 @@ def main(): # type: () -> None
|
|||
parser.add_argument("path", nargs="+", help="A path to an XML file or a directory containing XML files to parse.")
|
||||
group = parser.add_mutually_exclusive_group()
|
||||
group.add_argument("--output", "-o", default=".", help="The directory to save output .rst files in.")
|
||||
group.add_argument("--dry-run", action="store_true", help="If passed, no output will be generated and XML files are only checked for errors.")
|
||||
group.add_argument(
|
||||
"--dry-run",
|
||||
action="store_true",
|
||||
help="If passed, no output will be generated and XML files are only checked for errors.",
|
||||
)
|
||||
args = parser.parse_args()
|
||||
|
||||
file_list = [] # type: List[str]
|
||||
|
|
@ -283,15 +294,15 @@ def main(): # type: () -> None
|
|||
if path.endswith(os.sep):
|
||||
path = path[:-1]
|
||||
|
||||
if os.path.basename(path) == 'modules':
|
||||
if os.path.basename(path) == "modules":
|
||||
for subdir, dirs, _ in os.walk(path):
|
||||
if 'doc_classes' in dirs:
|
||||
doc_dir = os.path.join(subdir, 'doc_classes')
|
||||
class_file_names = (f for f in os.listdir(doc_dir) if f.endswith('.xml'))
|
||||
if "doc_classes" in dirs:
|
||||
doc_dir = os.path.join(subdir, "doc_classes")
|
||||
class_file_names = (f for f in os.listdir(doc_dir) if f.endswith(".xml"))
|
||||
file_list += (os.path.join(doc_dir, f) for f in class_file_names)
|
||||
|
||||
elif os.path.isdir(path):
|
||||
file_list += (os.path.join(path, f) for f in os.listdir(path) if f.endswith('.xml'))
|
||||
file_list += (os.path.join(path, f) for f in os.listdir(path) if f.endswith(".xml"))
|
||||
|
||||
elif os.path.isfile(path):
|
||||
if not path.endswith(".xml"):
|
||||
|
|
@ -311,7 +322,7 @@ def main(): # type: () -> None
|
|||
continue
|
||||
doc = tree.getroot()
|
||||
|
||||
if 'version' not in doc.attrib:
|
||||
if "version" not in doc.attrib:
|
||||
print_error("Version missing from 'doc', file: {}".format(cur_file), state)
|
||||
continue
|
||||
|
||||
|
|
@ -337,13 +348,14 @@ def main(): # type: () -> None
|
|||
if state.errored:
|
||||
exit(1)
|
||||
|
||||
|
||||
def make_rst_class(class_def, state, dry_run, output_dir): # type: (ClassDef, State, bool, str) -> None
|
||||
class_name = class_def.name
|
||||
|
||||
if dry_run:
|
||||
f = open(os.devnull, "w")
|
||||
else:
|
||||
f = open(os.path.join(output_dir, "class_" + class_name.lower() + '.rst'), 'w', encoding='utf-8')
|
||||
f = open(os.path.join(output_dir, "class_" + class_name.lower() + ".rst"), "w", encoding="utf-8")
|
||||
|
||||
# Warn contributors not to edit this file directly
|
||||
f.write(":github_url: hide\n\n")
|
||||
|
|
@ -352,13 +364,13 @@ def make_rst_class(class_def, state, dry_run, output_dir): # type: (ClassDef, S
|
|||
f.write(".. The source is found in doc/classes or modules/<name>/doc_classes.\n\n")
|
||||
|
||||
f.write(".. _class_" + class_name + ":\n\n")
|
||||
f.write(make_heading(class_name, '='))
|
||||
f.write(make_heading(class_name, "="))
|
||||
|
||||
# Inheritance tree
|
||||
# Ascendants
|
||||
if class_def.inherits:
|
||||
inh = class_def.inherits.strip()
|
||||
f.write('**Inherits:** ')
|
||||
f.write("**Inherits:** ")
|
||||
first = True
|
||||
while inh in state.classes:
|
||||
if not first:
|
||||
|
|
@ -381,7 +393,7 @@ def make_rst_class(class_def, state, dry_run, output_dir): # type: (ClassDef, S
|
|||
inherited.append(c.name)
|
||||
|
||||
if len(inherited):
|
||||
f.write('**Inherited By:** ')
|
||||
f.write("**Inherited By:** ")
|
||||
for i, child in enumerate(inherited):
|
||||
if i > 0:
|
||||
f.write(", ")
|
||||
|
|
@ -393,20 +405,20 @@ def make_rst_class(class_def, state, dry_run, output_dir): # type: (ClassDef, S
|
|||
f.write(rstize_text(class_def.brief_description.strip(), state) + "\n\n")
|
||||
|
||||
# Class description
|
||||
if class_def.description is not None and class_def.description.strip() != '':
|
||||
f.write(make_heading('Description', '-'))
|
||||
if class_def.description is not None and class_def.description.strip() != "":
|
||||
f.write(make_heading("Description", "-"))
|
||||
f.write(rstize_text(class_def.description.strip(), state) + "\n\n")
|
||||
|
||||
# Online tutorials
|
||||
if len(class_def.tutorials) > 0:
|
||||
f.write(make_heading('Tutorials', '-'))
|
||||
f.write(make_heading("Tutorials", "-"))
|
||||
for t in class_def.tutorials:
|
||||
link = t.strip()
|
||||
f.write("- " + make_url(link) + "\n\n")
|
||||
|
||||
# Properties overview
|
||||
if len(class_def.properties) > 0:
|
||||
f.write(make_heading('Properties', '-'))
|
||||
f.write(make_heading("Properties", "-"))
|
||||
ml = [] # type: List[Tuple[str, str, str]]
|
||||
for property_def in class_def.properties.values():
|
||||
type_rst = property_def.type_name.to_rst(state)
|
||||
|
|
@ -420,7 +432,7 @@ def make_rst_class(class_def, state, dry_run, output_dir): # type: (ClassDef, S
|
|||
|
||||
# Methods overview
|
||||
if len(class_def.methods) > 0:
|
||||
f.write(make_heading('Methods', '-'))
|
||||
f.write(make_heading("Methods", "-"))
|
||||
ml = []
|
||||
for method_list in class_def.methods.values():
|
||||
for m in method_list:
|
||||
|
|
@ -429,7 +441,7 @@ def make_rst_class(class_def, state, dry_run, output_dir): # type: (ClassDef, S
|
|||
|
||||
# Theme properties
|
||||
if class_def.theme_items is not None and len(class_def.theme_items) > 0:
|
||||
f.write(make_heading('Theme Properties', '-'))
|
||||
f.write(make_heading("Theme Properties", "-"))
|
||||
pl = []
|
||||
for theme_item_list in class_def.theme_items.values():
|
||||
for theme_item in theme_item_list:
|
||||
|
|
@ -438,30 +450,30 @@ def make_rst_class(class_def, state, dry_run, output_dir): # type: (ClassDef, S
|
|||
|
||||
# Signals
|
||||
if len(class_def.signals) > 0:
|
||||
f.write(make_heading('Signals', '-'))
|
||||
f.write(make_heading("Signals", "-"))
|
||||
index = 0
|
||||
|
||||
for signal in class_def.signals.values():
|
||||
if index != 0:
|
||||
f.write('----\n\n')
|
||||
f.write("----\n\n")
|
||||
|
||||
f.write(".. _class_{}_signal_{}:\n\n".format(class_name, signal.name))
|
||||
_, signature = make_method_signature(class_def, signal, False, state)
|
||||
f.write("- {}\n\n".format(signature))
|
||||
|
||||
if signal.description is not None and signal.description.strip() != '':
|
||||
f.write(rstize_text(signal.description.strip(), state) + '\n\n')
|
||||
if signal.description is not None and signal.description.strip() != "":
|
||||
f.write(rstize_text(signal.description.strip(), state) + "\n\n")
|
||||
|
||||
index += 1
|
||||
|
||||
# Enums
|
||||
if len(class_def.enums) > 0:
|
||||
f.write(make_heading('Enumerations', '-'))
|
||||
f.write(make_heading("Enumerations", "-"))
|
||||
index = 0
|
||||
|
||||
for e in class_def.enums.values():
|
||||
if index != 0:
|
||||
f.write('----\n\n')
|
||||
f.write("----\n\n")
|
||||
|
||||
f.write(".. _enum_{}_{}:\n\n".format(class_name, e.name))
|
||||
# Sphinx seems to divide the bullet list into individual <ul> tags if we weave the labels into it.
|
||||
|
|
@ -474,16 +486,16 @@ def make_rst_class(class_def, state, dry_run, output_dir): # type: (ClassDef, S
|
|||
f.write("enum **{}**:\n\n".format(e.name))
|
||||
for value in e.values.values():
|
||||
f.write("- **{}** = **{}**".format(value.name, value.value))
|
||||
if value.text is not None and value.text.strip() != '':
|
||||
f.write(' --- ' + rstize_text(value.text.strip(), state))
|
||||
if value.text is not None and value.text.strip() != "":
|
||||
f.write(" --- " + rstize_text(value.text.strip(), state))
|
||||
|
||||
f.write('\n\n')
|
||||
f.write("\n\n")
|
||||
|
||||
index += 1
|
||||
|
||||
# Constants
|
||||
if len(class_def.constants) > 0:
|
||||
f.write(make_heading('Constants', '-'))
|
||||
f.write(make_heading("Constants", "-"))
|
||||
# Sphinx seems to divide the bullet list into individual <ul> tags if we weave the labels into it.
|
||||
# As such I'll put them all above the list. Won't be perfect but better than making the list visually broken.
|
||||
for constant in class_def.constants.values():
|
||||
|
|
@ -491,14 +503,14 @@ def make_rst_class(class_def, state, dry_run, output_dir): # type: (ClassDef, S
|
|||
|
||||
for constant in class_def.constants.values():
|
||||
f.write("- **{}** = **{}**".format(constant.name, constant.value))
|
||||
if constant.text is not None and constant.text.strip() != '':
|
||||
f.write(' --- ' + rstize_text(constant.text.strip(), state))
|
||||
if constant.text is not None and constant.text.strip() != "":
|
||||
f.write(" --- " + rstize_text(constant.text.strip(), state))
|
||||
|
||||
f.write('\n\n')
|
||||
f.write("\n\n")
|
||||
|
||||
# Property descriptions
|
||||
if any(not p.overridden for p in class_def.properties.values()) > 0:
|
||||
f.write(make_heading('Property Descriptions', '-'))
|
||||
f.write(make_heading("Property Descriptions", "-"))
|
||||
index = 0
|
||||
|
||||
for property_def in class_def.properties.values():
|
||||
|
|
@ -506,36 +518,36 @@ def make_rst_class(class_def, state, dry_run, output_dir): # type: (ClassDef, S
|
|||
continue
|
||||
|
||||
if index != 0:
|
||||
f.write('----\n\n')
|
||||
f.write("----\n\n")
|
||||
|
||||
f.write(".. _class_{}_property_{}:\n\n".format(class_name, property_def.name))
|
||||
f.write('- {} **{}**\n\n'.format(property_def.type_name.to_rst(state), property_def.name))
|
||||
f.write("- {} **{}**\n\n".format(property_def.type_name.to_rst(state), property_def.name))
|
||||
|
||||
info = []
|
||||
if property_def.default_value is not None:
|
||||
info.append(("*Default*", property_def.default_value))
|
||||
if property_def.setter is not None and not property_def.setter.startswith("_"):
|
||||
info.append(("*Setter*", property_def.setter + '(value)'))
|
||||
info.append(("*Setter*", property_def.setter + "(value)"))
|
||||
if property_def.getter is not None and not property_def.getter.startswith("_"):
|
||||
info.append(('*Getter*', property_def.getter + '()'))
|
||||
info.append(("*Getter*", property_def.getter + "()"))
|
||||
|
||||
if len(info) > 0:
|
||||
format_table(f, info)
|
||||
|
||||
if property_def.text is not None and property_def.text.strip() != '':
|
||||
f.write(rstize_text(property_def.text.strip(), state) + '\n\n')
|
||||
if property_def.text is not None and property_def.text.strip() != "":
|
||||
f.write(rstize_text(property_def.text.strip(), state) + "\n\n")
|
||||
|
||||
index += 1
|
||||
|
||||
# Method descriptions
|
||||
if len(class_def.methods) > 0:
|
||||
f.write(make_heading('Method Descriptions', '-'))
|
||||
f.write(make_heading("Method Descriptions", "-"))
|
||||
index = 0
|
||||
|
||||
for method_list in class_def.methods.values():
|
||||
for i, m in enumerate(method_list):
|
||||
if index != 0:
|
||||
f.write('----\n\n')
|
||||
f.write("----\n\n")
|
||||
|
||||
if i == 0:
|
||||
f.write(".. _class_{}_method_{}:\n\n".format(class_name, m.name))
|
||||
|
|
@ -543,24 +555,24 @@ def make_rst_class(class_def, state, dry_run, output_dir): # type: (ClassDef, S
|
|||
ret_type, signature = make_method_signature(class_def, m, False, state)
|
||||
f.write("- {} {}\n\n".format(ret_type, signature))
|
||||
|
||||
if m.description is not None and m.description.strip() != '':
|
||||
f.write(rstize_text(m.description.strip(), state) + '\n\n')
|
||||
if m.description is not None and m.description.strip() != "":
|
||||
f.write(rstize_text(m.description.strip(), state) + "\n\n")
|
||||
|
||||
index += 1
|
||||
|
||||
|
||||
def make_class_list(class_list, columns): # type: (List[str], int) -> None
|
||||
# This function is no longer used.
|
||||
f = open('class_list.rst', 'w', encoding='utf-8')
|
||||
f = open("class_list.rst", "w", encoding="utf-8")
|
||||
col_max = len(class_list) // columns + 1
|
||||
print(('col max is ', col_max))
|
||||
print(("col max is ", col_max))
|
||||
fit_columns = [] # type: List[List[str]]
|
||||
|
||||
for _ in range(0, columns):
|
||||
fit_columns.append([])
|
||||
|
||||
indexers = [] # type List[str]
|
||||
last_initial = ''
|
||||
last_initial = ""
|
||||
|
||||
for idx, name in enumerate(class_list):
|
||||
col = idx // col_max
|
||||
|
|
@ -590,7 +602,7 @@ def make_class_list(class_list, columns): # type: (List[str], int) -> None
|
|||
f.write("\n")
|
||||
|
||||
for r in range(0, row_max):
|
||||
s = '+ '
|
||||
s = "+ "
|
||||
for c in range(0, columns):
|
||||
if r >= len(fit_columns[c]):
|
||||
continue
|
||||
|
|
@ -598,13 +610,13 @@ def make_class_list(class_list, columns): # type: (List[str], int) -> None
|
|||
classname = fit_columns[c][r]
|
||||
initial = classname[0]
|
||||
if classname in indexers:
|
||||
s += '**' + initial + '** | '
|
||||
s += "**" + initial + "** | "
|
||||
else:
|
||||
s += ' | '
|
||||
s += " | "
|
||||
|
||||
s += '[' + classname + '](class_' + classname.lower() + ') | '
|
||||
s += "[" + classname + "](class_" + classname.lower() + ") | "
|
||||
|
||||
s += '\n'
|
||||
s += "\n"
|
||||
f.write(s)
|
||||
|
||||
for n in range(0, columns):
|
||||
|
|
@ -618,7 +630,7 @@ def escape_rst(text, until_pos=-1): # type: (str) -> str
|
|||
# Escape \ character, otherwise it ends up as an escape character in rst
|
||||
pos = 0
|
||||
while True:
|
||||
pos = text.find('\\', pos, until_pos)
|
||||
pos = text.find("\\", pos, until_pos)
|
||||
if pos == -1:
|
||||
break
|
||||
text = text[:pos] + "\\\\" + text[pos + 1 :]
|
||||
|
|
@ -627,7 +639,7 @@ def escape_rst(text, until_pos=-1): # type: (str) -> str
|
|||
# Escape * character to avoid interpreting it as emphasis
|
||||
pos = 0
|
||||
while True:
|
||||
pos = text.find('*', pos, until_pos)
|
||||
pos = text.find("*", pos, until_pos)
|
||||
if pos == -1:
|
||||
break
|
||||
text = text[:pos] + "\*" + text[pos + 1 :]
|
||||
|
|
@ -636,7 +648,7 @@ def escape_rst(text, until_pos=-1): # type: (str) -> str
|
|||
# Escape _ character at the end of a word to avoid interpreting it as an inline hyperlink
|
||||
pos = 0
|
||||
while True:
|
||||
pos = text.find('_', pos, until_pos)
|
||||
pos = text.find("_", pos, until_pos)
|
||||
if pos == -1:
|
||||
break
|
||||
if not text[pos + 1].isalnum(): # don't escape within a snake_case word
|
||||
|
|
@ -652,13 +664,13 @@ def rstize_text(text, state): # type: (str, State) -> str
|
|||
# Linebreak + tabs in the XML should become two line breaks unless in a "codeblock"
|
||||
pos = 0
|
||||
while True:
|
||||
pos = text.find('\n', pos)
|
||||
pos = text.find("\n", pos)
|
||||
if pos == -1:
|
||||
break
|
||||
|
||||
pre_text = text[:pos]
|
||||
indent_level = 0
|
||||
while text[pos + 1] == '\t':
|
||||
while text[pos + 1] == "\t":
|
||||
pos += 1
|
||||
indent_level += 1
|
||||
post_text = text[pos + 1 :]
|
||||
|
|
@ -676,16 +688,21 @@ def rstize_text(text, state): # type: (str, State) -> str
|
|||
# Remove extraneous tabs
|
||||
code_pos = 0
|
||||
while True:
|
||||
code_pos = code_text.find('\n', code_pos)
|
||||
code_pos = code_text.find("\n", code_pos)
|
||||
if code_pos == -1:
|
||||
break
|
||||
|
||||
to_skip = 0
|
||||
while code_pos + to_skip + 1 < len(code_text) and code_text[code_pos + to_skip + 1] == '\t':
|
||||
while code_pos + to_skip + 1 < len(code_text) and code_text[code_pos + to_skip + 1] == "\t":
|
||||
to_skip += 1
|
||||
|
||||
if to_skip > indent_level:
|
||||
print_error("Four spaces should be used for indentation within [codeblock], file: {}".format(state.current_class), state)
|
||||
print_error(
|
||||
"Four spaces should be used for indentation within [codeblock], file: {}".format(
|
||||
state.current_class
|
||||
),
|
||||
state,
|
||||
)
|
||||
|
||||
if len(code_text[code_pos + to_skip + 1 :]) == 0:
|
||||
code_text = code_text[:code_pos] + "\n"
|
||||
|
|
@ -702,7 +719,7 @@ def rstize_text(text, state): # type: (str, State) -> str
|
|||
text = pre_text + "\n\n" + post_text
|
||||
pos += 2
|
||||
|
||||
next_brac_pos = text.find('[')
|
||||
next_brac_pos = text.find("[")
|
||||
text = escape_rst(text, next_brac_pos)
|
||||
|
||||
# Handle [tags]
|
||||
|
|
@ -714,13 +731,13 @@ def rstize_text(text, state): # type: (str, State) -> str
|
|||
tag_depth = 0
|
||||
previous_pos = 0
|
||||
while True:
|
||||
pos = text.find('[', pos)
|
||||
pos = text.find("[", pos)
|
||||
if inside_url and (pos > previous_pos):
|
||||
url_has_name = True
|
||||
if pos == -1:
|
||||
break
|
||||
|
||||
endq_pos = text.find(']', pos + 1)
|
||||
endq_pos = text.find("]", pos + 1)
|
||||
if endq_pos == -1:
|
||||
break
|
||||
|
||||
|
|
@ -733,35 +750,40 @@ def rstize_text(text, state): # type: (str, State) -> str
|
|||
if tag_text in state.classes:
|
||||
if tag_text == state.current_class:
|
||||
# We don't want references to the same class
|
||||
tag_text = '``{}``'.format(tag_text)
|
||||
tag_text = "``{}``".format(tag_text)
|
||||
else:
|
||||
tag_text = make_type(tag_text, state)
|
||||
escape_post = True
|
||||
else: # command
|
||||
cmd = tag_text
|
||||
space_pos = tag_text.find(' ')
|
||||
if cmd == '/codeblock':
|
||||
tag_text = ''
|
||||
space_pos = tag_text.find(" ")
|
||||
if cmd == "/codeblock":
|
||||
tag_text = ""
|
||||
tag_depth -= 1
|
||||
inside_code = False
|
||||
# Strip newline if the tag was alone on one
|
||||
if pre_text[-1] == '\n':
|
||||
if pre_text[-1] == "\n":
|
||||
pre_text = pre_text[:-1]
|
||||
elif cmd == '/code':
|
||||
tag_text = '``'
|
||||
elif cmd == "/code":
|
||||
tag_text = "``"
|
||||
tag_depth -= 1
|
||||
inside_code = False
|
||||
escape_post = True
|
||||
elif inside_code:
|
||||
tag_text = '[' + tag_text + ']'
|
||||
elif cmd.find('html') == 0:
|
||||
tag_text = "[" + tag_text + "]"
|
||||
elif cmd.find("html") == 0:
|
||||
param = tag_text[space_pos + 1 :]
|
||||
tag_text = param
|
||||
elif cmd.startswith('method') or cmd.startswith('member') or cmd.startswith('signal') or cmd.startswith('constant'):
|
||||
elif (
|
||||
cmd.startswith("method")
|
||||
or cmd.startswith("member")
|
||||
or cmd.startswith("signal")
|
||||
or cmd.startswith("constant")
|
||||
):
|
||||
param = tag_text[space_pos + 1 :]
|
||||
|
||||
if param.find('.') != -1:
|
||||
ss = param.split('.')
|
||||
if param.find(".") != -1:
|
||||
ss = param.split(".")
|
||||
if len(ss) > 2:
|
||||
print_error("Bad reference: '{}', file: {}".format(param, state.current_class), state)
|
||||
class_param, method_param = ss
|
||||
|
|
@ -794,7 +816,7 @@ def rstize_text(text, state): # type: (str, State) -> str
|
|||
# Search in the current class
|
||||
search_class_defs = [class_def]
|
||||
|
||||
if param.find('.') == -1:
|
||||
if param.find(".") == -1:
|
||||
# Also search in @GlobalScope as a last resort if no class was specified
|
||||
search_class_defs.append(state.classes["@GlobalScope"])
|
||||
|
||||
|
|
@ -815,66 +837,71 @@ def rstize_text(text, state): # type: (str, State) -> str
|
|||
ref_type = "_constant"
|
||||
|
||||
else:
|
||||
print_error("Unresolved type reference '{}' in method reference '{}', file: {}".format(class_param, param, state.current_class), state)
|
||||
print_error(
|
||||
"Unresolved type reference '{}' in method reference '{}', file: {}".format(
|
||||
class_param, param, state.current_class
|
||||
),
|
||||
state,
|
||||
)
|
||||
|
||||
repl_text = method_param
|
||||
if class_param != state.current_class:
|
||||
repl_text = "{}.{}".format(class_param, method_param)
|
||||
tag_text = ':ref:`{}<class_{}{}_{}>`'.format(repl_text, class_param, ref_type, method_param)
|
||||
tag_text = ":ref:`{}<class_{}{}_{}>`".format(repl_text, class_param, ref_type, method_param)
|
||||
escape_post = True
|
||||
elif cmd.find('image=') == 0:
|
||||
elif cmd.find("image=") == 0:
|
||||
tag_text = "" # ''
|
||||
elif cmd.find('url=') == 0:
|
||||
elif cmd.find("url=") == 0:
|
||||
url_link = cmd[4:]
|
||||
tag_text = '`'
|
||||
tag_text = "`"
|
||||
tag_depth += 1
|
||||
inside_url = True
|
||||
url_has_name = False
|
||||
elif cmd == '/url':
|
||||
tag_text = ('' if url_has_name else url_link) + " <" + url_link + ">`_"
|
||||
elif cmd == "/url":
|
||||
tag_text = ("" if url_has_name else url_link) + " <" + url_link + ">`_"
|
||||
tag_depth -= 1
|
||||
escape_post = True
|
||||
inside_url = False
|
||||
url_has_name = False
|
||||
elif cmd == 'center':
|
||||
elif cmd == "center":
|
||||
tag_depth += 1
|
||||
tag_text = ''
|
||||
elif cmd == '/center':
|
||||
tag_text = ""
|
||||
elif cmd == "/center":
|
||||
tag_depth -= 1
|
||||
tag_text = ''
|
||||
elif cmd == 'codeblock':
|
||||
tag_text = ""
|
||||
elif cmd == "codeblock":
|
||||
tag_depth += 1
|
||||
tag_text = '\n::\n'
|
||||
tag_text = "\n::\n"
|
||||
inside_code = True
|
||||
elif cmd == 'br':
|
||||
elif cmd == "br":
|
||||
# Make a new paragraph instead of a linebreak, rst is not so linebreak friendly
|
||||
tag_text = '\n\n'
|
||||
tag_text = "\n\n"
|
||||
# Strip potential leading spaces
|
||||
while post_text[0] == ' ':
|
||||
while post_text[0] == " ":
|
||||
post_text = post_text[1:]
|
||||
elif cmd == 'i' or cmd == '/i':
|
||||
elif cmd == "i" or cmd == "/i":
|
||||
if cmd == "/i":
|
||||
tag_depth -= 1
|
||||
else:
|
||||
tag_depth += 1
|
||||
tag_text = '*'
|
||||
elif cmd == 'b' or cmd == '/b':
|
||||
tag_text = "*"
|
||||
elif cmd == "b" or cmd == "/b":
|
||||
if cmd == "/b":
|
||||
tag_depth -= 1
|
||||
else:
|
||||
tag_depth += 1
|
||||
tag_text = '**'
|
||||
elif cmd == 'u' or cmd == '/u':
|
||||
tag_text = "**"
|
||||
elif cmd == "u" or cmd == "/u":
|
||||
if cmd == "/u":
|
||||
tag_depth -= 1
|
||||
else:
|
||||
tag_depth += 1
|
||||
tag_text = ''
|
||||
elif cmd == 'code':
|
||||
tag_text = '``'
|
||||
tag_text = ""
|
||||
elif cmd == "code":
|
||||
tag_text = "``"
|
||||
tag_depth += 1
|
||||
inside_code = True
|
||||
elif cmd.startswith('enum '):
|
||||
elif cmd.startswith("enum "):
|
||||
tag_text = make_enum(cmd[5:], state)
|
||||
escape_post = True
|
||||
else:
|
||||
|
|
@ -883,12 +910,12 @@ def rstize_text(text, state): # type: (str, State) -> str
|
|||
|
||||
# Properly escape things like `[Node]s`
|
||||
if escape_post and post_text and (post_text[0].isalnum() or post_text[0] == "("): # not punctuation, escape
|
||||
post_text = '\ ' + post_text
|
||||
post_text = "\ " + post_text
|
||||
|
||||
next_brac_pos = post_text.find('[', 0)
|
||||
next_brac_pos = post_text.find("[", 0)
|
||||
iter_pos = 0
|
||||
while not inside_code:
|
||||
iter_pos = post_text.find('*', iter_pos, next_brac_pos)
|
||||
iter_pos = post_text.find("*", iter_pos, next_brac_pos)
|
||||
if iter_pos == -1:
|
||||
break
|
||||
post_text = post_text[:iter_pos] + "\*" + post_text[iter_pos + 1 :]
|
||||
|
|
@ -896,7 +923,7 @@ def rstize_text(text, state): # type: (str, State) -> str
|
|||
|
||||
iter_pos = 0
|
||||
while not inside_code:
|
||||
iter_pos = post_text.find('_', iter_pos, next_brac_pos)
|
||||
iter_pos = post_text.find("_", iter_pos, next_brac_pos)
|
||||
if iter_pos == -1:
|
||||
break
|
||||
if not post_text[iter_pos + 1].isalnum(): # don't escape within a snake_case word
|
||||
|
|
@ -922,7 +949,7 @@ def format_table(f, data, remove_empty_columns=False): # type: (TextIO, Iterabl
|
|||
column_sizes = [0] * len(data[0])
|
||||
for row in data:
|
||||
for i, text in enumerate(row):
|
||||
text_length = len(text or '')
|
||||
text_length = len(text or "")
|
||||
if text_length > column_sizes[i]:
|
||||
column_sizes[i] = text_length
|
||||
|
||||
|
|
@ -939,16 +966,16 @@ def format_table(f, data, remove_empty_columns=False): # type: (TextIO, Iterabl
|
|||
for i, text in enumerate(row):
|
||||
if column_sizes[i] == 0 and remove_empty_columns:
|
||||
continue
|
||||
row_text += " " + (text or '').ljust(column_sizes[i]) + " |"
|
||||
row_text += " " + (text or "").ljust(column_sizes[i]) + " |"
|
||||
row_text += "\n"
|
||||
f.write(row_text)
|
||||
f.write(sep)
|
||||
f.write('\n')
|
||||
f.write("\n")
|
||||
|
||||
|
||||
def make_type(t, state): # type: (str, State) -> str
|
||||
if t in state.classes:
|
||||
return ':ref:`{0}<class_{0}>`'.format(t)
|
||||
return ":ref:`{0}<class_{0}>`".format(t)
|
||||
print_error("Unresolved type '{}', file: {}".format(t, state.current_class), state)
|
||||
return t
|
||||
|
||||
|
|
@ -981,7 +1008,9 @@ def make_enum(t, state): # type: (str, State) -> str
|
|||
return t
|
||||
|
||||
|
||||
def make_method_signature(class_def, method_def, make_ref, state): # type: (ClassDef, Union[MethodDef, SignalDef], bool, State) -> Tuple[str, str]
|
||||
def make_method_signature(
|
||||
class_def, method_def, make_ref, state
|
||||
): # type: (ClassDef, Union[MethodDef, SignalDef], bool, State) -> Tuple[str, str]
|
||||
ret_type = " "
|
||||
|
||||
ref_type = "signal"
|
||||
|
|
@ -996,34 +1025,34 @@ def make_method_signature(class_def, method_def, make_ref, state): # type: (Cla
|
|||
else:
|
||||
out += "**{}** ".format(method_def.name)
|
||||
|
||||
out += '**(**'
|
||||
out += "**(**"
|
||||
for i, arg in enumerate(method_def.parameters):
|
||||
if i > 0:
|
||||
out += ', '
|
||||
out += ", "
|
||||
else:
|
||||
out += ' '
|
||||
out += " "
|
||||
|
||||
out += "{} {}".format(arg.type_name.to_rst(state), arg.name)
|
||||
|
||||
if arg.default_value is not None:
|
||||
out += '=' + arg.default_value
|
||||
out += "=" + arg.default_value
|
||||
|
||||
if isinstance(method_def, MethodDef) and method_def.qualifiers is not None and 'vararg' in method_def.qualifiers:
|
||||
if isinstance(method_def, MethodDef) and method_def.qualifiers is not None and "vararg" in method_def.qualifiers:
|
||||
if len(method_def.parameters) > 0:
|
||||
out += ', ...'
|
||||
out += ", ..."
|
||||
else:
|
||||
out += ' ...'
|
||||
out += " ..."
|
||||
|
||||
out += ' **)**'
|
||||
out += " **)**"
|
||||
|
||||
if isinstance(method_def, MethodDef) and method_def.qualifiers is not None:
|
||||
out += ' ' + method_def.qualifiers
|
||||
out += " " + method_def.qualifiers
|
||||
|
||||
return ret_type, out
|
||||
|
||||
|
||||
def make_heading(title, underline): # type: (str, str) -> str
|
||||
return title + '\n' + (underline * len(title)) + "\n\n"
|
||||
return title + "\n" + (underline * len(title)) + "\n\n"
|
||||
|
||||
|
||||
def make_url(link): # type: (str) -> str
|
||||
|
|
@ -1047,5 +1076,5 @@ def make_url(link): # type: (str) -> str
|
|||
return "`" + link + " <" + link + ">`_"
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
|
|
|
|||
|
|
@ -7,7 +7,7 @@ import shutil
|
|||
from collections import OrderedDict
|
||||
|
||||
EXTRACT_TAGS = ["description", "brief_description", "member", "constant", "theme_item", "link"]
|
||||
HEADER = '''\
|
||||
HEADER = """\
|
||||
# LANGUAGE translation of the Godot Engine class reference.
|
||||
# Copyright (c) 2007-2020 Juan Linietsky, Ariel Manzur.
|
||||
# Copyright (c) 2014-2020 Godot Engine contributors (cf. AUTHORS.md).
|
||||
|
|
@ -24,7 +24,7 @@ msgstr ""
|
|||
"Content-Type: text/plain; charset=UTF-8\\n"
|
||||
"Content-Transfer-Encoding: 8-bit\\n"
|
||||
|
||||
'''
|
||||
"""
|
||||
# Some strings used by makerst.py are normally part of the editor translations,
|
||||
# so we need to include them manually here for the online docs.
|
||||
BASE_STRINGS = [
|
||||
|
|
@ -42,7 +42,8 @@ BASE_STRINGS = [
|
|||
|
||||
## <xml-line-number-hack from="https://stackoverflow.com/a/36430270/10846399">
|
||||
import sys
|
||||
sys.modules['_elementtree'] = None
|
||||
|
||||
sys.modules["_elementtree"] = None
|
||||
import xml.etree.ElementTree as ET
|
||||
|
||||
## override the parser to get the line number
|
||||
|
|
@ -62,8 +63,11 @@ class LineNumberingParser(ET.XMLParser):
|
|||
element._end_column_number = self.parser.CurrentColumnNumber
|
||||
element._end_byte_index = self.parser.CurrentByteIndex
|
||||
return element
|
||||
|
||||
|
||||
## </xml-line-number-hack>
|
||||
|
||||
|
||||
class Desc:
|
||||
def __init__(self, line_no, msg, desc_list=None):
|
||||
## line_no : the line number where the desc is
|
||||
|
|
@ -73,6 +77,7 @@ class Desc:
|
|||
self.msg = msg
|
||||
self.desc_list = desc_list
|
||||
|
||||
|
||||
class DescList:
|
||||
def __init__(self, doc, path):
|
||||
## doc : root xml element of the document
|
||||
|
|
@ -82,9 +87,11 @@ class DescList:
|
|||
self.path = path
|
||||
self.list = []
|
||||
|
||||
|
||||
def print_error(error):
|
||||
print("ERROR: {}".format(error))
|
||||
|
||||
|
||||
## build classes with xml elements recursively
|
||||
def _collect_classes_dir(path, classes):
|
||||
if not os.path.isdir(path):
|
||||
|
|
@ -99,12 +106,13 @@ def _collect_classes_dir(path, classes):
|
|||
continue
|
||||
_collect_classes_file(_dir, classes)
|
||||
|
||||
|
||||
## opens a file and parse xml add to classes
|
||||
def _collect_classes_file(path, classes):
|
||||
if not os.path.isfile(path) or not path.endswith(".xml"):
|
||||
print_error("Invalid xml file path: {}".format(path))
|
||||
exit(1)
|
||||
print('Collecting file: {}'.format(os.path.basename(path)))
|
||||
print("Collecting file: {}".format(os.path.basename(path)))
|
||||
|
||||
try:
|
||||
tree = ET.parse(path, parser=LineNumberingParser())
|
||||
|
|
@ -114,8 +122,8 @@ def _collect_classes_file(path, classes):
|
|||
|
||||
doc = tree.getroot()
|
||||
|
||||
if 'name' in doc.attrib:
|
||||
if 'version' not in doc.attrib:
|
||||
if "name" in doc.attrib:
|
||||
if "version" not in doc.attrib:
|
||||
print_error("Version missing from 'doc', file: {}".format(path))
|
||||
|
||||
name = doc.attrib["name"]
|
||||
|
|
@ -124,7 +132,7 @@ def _collect_classes_file(path, classes):
|
|||
exit(1)
|
||||
classes[name] = DescList(doc, path)
|
||||
else:
|
||||
print_error('Unknown XML file {}, skipping'.format(path))
|
||||
print_error("Unknown XML file {}, skipping".format(path))
|
||||
|
||||
|
||||
## regions are list of tuples with size 3 (start_index, end_index, indent)
|
||||
|
|
@ -136,52 +144,60 @@ def _get_xml_indent(i, regions):
|
|||
return region[2]
|
||||
return -1
|
||||
|
||||
|
||||
## find and build all regions of codeblock which we need later
|
||||
def _make_codeblock_regions(desc, path=''):
|
||||
def _make_codeblock_regions(desc, path=""):
|
||||
code_block_end = False
|
||||
code_block_index = 0
|
||||
code_block_regions = []
|
||||
while not code_block_end:
|
||||
code_block_index = desc.find("[codeblock]", code_block_index)
|
||||
if code_block_index < 0: break
|
||||
if code_block_index < 0:
|
||||
break
|
||||
xml_indent = 0
|
||||
while True:
|
||||
## [codeblock] always have a trailing new line and some tabs
|
||||
## those tabs are belongs to xml indentations not code indent
|
||||
if desc[code_block_index+len("[codeblock]\n")+xml_indent] == '\t':
|
||||
if desc[code_block_index + len("[codeblock]\n") + xml_indent] == "\t":
|
||||
xml_indent += 1
|
||||
else: break
|
||||
else:
|
||||
break
|
||||
end_index = desc.find("[/codeblock]", code_block_index)
|
||||
if end_index < 0:
|
||||
print_error('Non terminating codeblock: {}'.format(path))
|
||||
print_error("Non terminating codeblock: {}".format(path))
|
||||
exit(1)
|
||||
code_block_regions.append((code_block_index, end_index, xml_indent))
|
||||
code_block_index += 1
|
||||
return code_block_regions
|
||||
|
||||
|
||||
def _strip_and_split_desc(desc, code_block_regions):
|
||||
desc_strip = '' ## a stripped desc msg
|
||||
desc_strip = "" ## a stripped desc msg
|
||||
total_indent = 0 ## code indent = total indent - xml indent
|
||||
for i in range(len(desc)):
|
||||
c = desc[i]
|
||||
if c == '\n' : c = '\\n'
|
||||
if c == '"': c = '\\"'
|
||||
if c == '\\': c = '\\\\' ## <element \> is invalid for msgmerge
|
||||
if c == '\t':
|
||||
if c == "\n":
|
||||
c = "\\n"
|
||||
if c == '"':
|
||||
c = '\\"'
|
||||
if c == "\\":
|
||||
c = "\\\\" ## <element \> is invalid for msgmerge
|
||||
if c == "\t":
|
||||
xml_indent = _get_xml_indent(i, code_block_regions)
|
||||
if xml_indent >= 0:
|
||||
total_indent += 1
|
||||
if xml_indent < total_indent:
|
||||
c = '\\t'
|
||||
c = "\\t"
|
||||
else:
|
||||
continue
|
||||
else:
|
||||
continue
|
||||
desc_strip += c
|
||||
if c == '\\n':
|
||||
if c == "\\n":
|
||||
total_indent = 0
|
||||
return desc_strip
|
||||
|
||||
|
||||
## make catalog strings from xml elements
|
||||
def _make_translation_catalog(classes):
|
||||
unique_msgs = OrderedDict()
|
||||
|
|
@ -189,8 +205,9 @@ def _make_translation_catalog(classes):
|
|||
desc_list = classes[class_name]
|
||||
for elem in desc_list.doc.iter():
|
||||
if elem.tag in EXTRACT_TAGS:
|
||||
if not elem.text or len(elem.text) == 0 : continue
|
||||
line_no = elem._start_line_number if elem.text[0]!='\n' else elem._start_line_number+1
|
||||
if not elem.text or len(elem.text) == 0:
|
||||
continue
|
||||
line_no = elem._start_line_number if elem.text[0] != "\n" else elem._start_line_number + 1
|
||||
desc_str = elem.text.strip()
|
||||
code_block_regions = _make_codeblock_regions(desc_str, desc_list.path)
|
||||
desc_msg = _strip_and_split_desc(desc_str, code_block_regions)
|
||||
|
|
@ -203,44 +220,48 @@ def _make_translation_catalog(classes):
|
|||
unique_msgs[desc_msg].append(desc_obj)
|
||||
return unique_msgs
|
||||
|
||||
|
||||
## generate the catalog file
|
||||
def _generate_translation_catalog_file(unique_msgs, output):
|
||||
with open(output, 'w', encoding='utf8') as f:
|
||||
with open(output, "w", encoding="utf8") as f:
|
||||
f.write(HEADER)
|
||||
for msg in BASE_STRINGS:
|
||||
f.write('#: doc/tools/makerst.py\n')
|
||||
f.write("#: doc/tools/makerst.py\n")
|
||||
f.write('msgid "{}"\n'.format(msg))
|
||||
f.write('msgstr ""\n\n')
|
||||
for msg in unique_msgs:
|
||||
if len(msg) == 0 or msg in BASE_STRINGS:
|
||||
continue
|
||||
|
||||
f.write('#:')
|
||||
f.write("#:")
|
||||
desc_list = unique_msgs[msg]
|
||||
for desc in desc_list:
|
||||
path = desc.desc_list.path.replace('\\', '/')
|
||||
if path.startswith('./'):
|
||||
path = desc.desc_list.path.replace("\\", "/")
|
||||
if path.startswith("./"):
|
||||
path = path[2:]
|
||||
f.write(' {}:{}'.format(path, desc.line_no))
|
||||
f.write('\n')
|
||||
f.write(" {}:{}".format(path, desc.line_no))
|
||||
f.write("\n")
|
||||
|
||||
f.write('msgid "{}"\n'.format(msg))
|
||||
f.write('msgstr ""\n\n')
|
||||
|
||||
## TODO: what if 'nt'?
|
||||
if (os.name == "posix"):
|
||||
if os.name == "posix":
|
||||
print("Wrapping template at 79 characters for compatibility with Weblate.")
|
||||
os.system("msgmerge -w79 {0} {0} > {0}.wrap".format(output))
|
||||
shutil.move("{}.wrap".format(output), output)
|
||||
|
||||
|
||||
def main():
|
||||
parser = argparse.ArgumentParser()
|
||||
parser.add_argument("--path", "-p", nargs="+", default=".", help="The directory or directories containing XML files to collect.")
|
||||
parser.add_argument(
|
||||
"--path", "-p", nargs="+", default=".", help="The directory or directories containing XML files to collect."
|
||||
)
|
||||
parser.add_argument("--output", "-o", default="translation_catalog.pot", help="The path to the output file.")
|
||||
args = parser.parse_args()
|
||||
|
||||
output = os.path.abspath(args.output)
|
||||
if not os.path.isdir(os.path.dirname(output)) or not output.endswith('.pot'):
|
||||
if not os.path.isdir(os.path.dirname(output)) or not output.endswith(".pot"):
|
||||
print_error("Invalid output path: {}".format(output))
|
||||
exit(1)
|
||||
|
||||
|
|
@ -260,5 +281,6 @@ def main():
|
|||
unique_msgs = _make_translation_catalog(classes)
|
||||
_generate_translation_catalog_file(unique_msgs, output)
|
||||
|
||||
if __name__ == '__main__':
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
|
|
|
|||
|
|
@ -1,41 +1,42 @@
|
|||
#!/usr/bin/env python
|
||||
|
||||
Import('env')
|
||||
Import("env")
|
||||
|
||||
env.drivers_sources = []
|
||||
|
||||
# OS drivers
|
||||
SConscript('unix/SCsub')
|
||||
SConscript('windows/SCsub')
|
||||
SConscript("unix/SCsub")
|
||||
SConscript("windows/SCsub")
|
||||
|
||||
# Sounds drivers
|
||||
SConscript('alsa/SCsub')
|
||||
SConscript('coreaudio/SCsub')
|
||||
SConscript('pulseaudio/SCsub')
|
||||
if (env["platform"] == "windows"):
|
||||
SConscript("alsa/SCsub")
|
||||
SConscript("coreaudio/SCsub")
|
||||
SConscript("pulseaudio/SCsub")
|
||||
if env["platform"] == "windows":
|
||||
SConscript("wasapi/SCsub")
|
||||
if env['xaudio2']:
|
||||
if env["xaudio2"]:
|
||||
SConscript("xaudio2/SCsub")
|
||||
|
||||
# Midi drivers
|
||||
SConscript('alsamidi/SCsub')
|
||||
SConscript('coremidi/SCsub')
|
||||
SConscript('winmidi/SCsub')
|
||||
SConscript("alsamidi/SCsub")
|
||||
SConscript("coremidi/SCsub")
|
||||
SConscript("winmidi/SCsub")
|
||||
|
||||
# Graphics drivers
|
||||
if (env["platform"] != "server" and env["platform"] != "javascript"):
|
||||
if env["platform"] != "server" and env["platform"] != "javascript":
|
||||
# SConscript('gles2/SCsub')
|
||||
SConscript('vulkan/SCsub')
|
||||
SConscript('gl_context/SCsub')
|
||||
SConscript("vulkan/SCsub")
|
||||
SConscript("gl_context/SCsub")
|
||||
else:
|
||||
SConscript('dummy/SCsub')
|
||||
SConscript("dummy/SCsub")
|
||||
|
||||
# Core dependencies
|
||||
SConscript("png/SCsub")
|
||||
SConscript("spirv-reflect/SCsub")
|
||||
|
||||
if env['vsproj']:
|
||||
if env["vsproj"]:
|
||||
import os
|
||||
|
||||
path = os.getcwd()
|
||||
# Change directory so the path resolves correctly in the function call.
|
||||
os.chdir("..")
|
||||
|
|
|
|||
|
|
@ -1,5 +1,5 @@
|
|||
#!/usr/bin/env python
|
||||
|
||||
Import('env')
|
||||
Import("env")
|
||||
|
||||
env.add_source_files(env.drivers_sources, "*.cpp")
|
||||
|
|
|
|||
|
|
@ -1,6 +1,6 @@
|
|||
#!/usr/bin/env python
|
||||
|
||||
Import('env')
|
||||
Import("env")
|
||||
|
||||
# Driver source files
|
||||
env.add_source_files(env.drivers_sources, "*.cpp")
|
||||
|
|
|
|||
|
|
@ -1,6 +1,6 @@
|
|||
#!/usr/bin/env python
|
||||
|
||||
Import('env')
|
||||
Import("env")
|
||||
|
||||
# Driver source files
|
||||
env.add_source_files(env.drivers_sources, "*.cpp")
|
||||
|
|
|
|||
|
|
@ -1,6 +1,6 @@
|
|||
#!/usr/bin/env python
|
||||
|
||||
Import('env')
|
||||
Import("env")
|
||||
|
||||
# Driver source files
|
||||
env.add_source_files(env.drivers_sources, "*.cpp")
|
||||
|
|
|
|||
|
|
@ -1,5 +1,5 @@
|
|||
#!/usr/bin/env python
|
||||
|
||||
Import('env')
|
||||
Import("env")
|
||||
|
||||
env.add_source_files(env.drivers_sources, "*.cpp")
|
||||
|
|
|
|||
|
|
@ -1,8 +1,8 @@
|
|||
#!/usr/bin/env python
|
||||
|
||||
Import('env')
|
||||
Import("env")
|
||||
|
||||
if (env["platform"] in ["haiku", "osx", "windows", "linuxbsd"]):
|
||||
if env["platform"] in ["haiku", "osx", "windows", "linuxbsd"]:
|
||||
# Thirdparty source files
|
||||
thirdparty_dir = "#thirdparty/glad/"
|
||||
thirdparty_sources = [
|
||||
|
|
@ -12,8 +12,8 @@ if (env["platform"] in ["haiku", "osx", "windows", "linuxbsd"]):
|
|||
|
||||
env.Prepend(CPPPATH=[thirdparty_dir])
|
||||
|
||||
env.Append(CPPDEFINES=['GLAD_ENABLED'])
|
||||
env.Append(CPPDEFINES=['GLES_OVER_GL'])
|
||||
env.Append(CPPDEFINES=["GLAD_ENABLED"])
|
||||
env.Append(CPPDEFINES=["GLES_OVER_GL"])
|
||||
|
||||
env_thirdparty = env.Clone()
|
||||
env_thirdparty.disable_warnings()
|
||||
|
|
|
|||
|
|
@ -1,6 +1,6 @@
|
|||
#!/usr/bin/env python
|
||||
|
||||
Import('env')
|
||||
Import("env")
|
||||
|
||||
env.add_source_files(env.drivers_sources, "*.cpp")
|
||||
|
||||
|
|
|
|||
|
|
@ -1,23 +1,23 @@
|
|||
#!/usr/bin/env python
|
||||
|
||||
Import('env')
|
||||
Import("env")
|
||||
|
||||
if 'GLES2_GLSL' in env['BUILDERS']:
|
||||
env.GLES2_GLSL('copy.glsl');
|
||||
if "GLES2_GLSL" in env["BUILDERS"]:
|
||||
env.GLES2_GLSL("copy.glsl")
|
||||
# env.GLES2_GLSL('resolve.glsl');
|
||||
env.GLES2_GLSL('canvas.glsl');
|
||||
env.GLES2_GLSL('canvas_shadow.glsl');
|
||||
env.GLES2_GLSL('scene.glsl');
|
||||
env.GLES2_GLSL('cubemap_filter.glsl');
|
||||
env.GLES2_GLSL('cube_to_dp.glsl');
|
||||
env.GLES2_GLSL("canvas.glsl")
|
||||
env.GLES2_GLSL("canvas_shadow.glsl")
|
||||
env.GLES2_GLSL("scene.glsl")
|
||||
env.GLES2_GLSL("cubemap_filter.glsl")
|
||||
env.GLES2_GLSL("cube_to_dp.glsl")
|
||||
# env.GLES2_GLSL('blend_shape.glsl');
|
||||
# env.GLES2_GLSL('screen_space_reflection.glsl');
|
||||
env.GLES2_GLSL('effect_blur.glsl');
|
||||
env.GLES2_GLSL("effect_blur.glsl")
|
||||
# env.GLES2_GLSL('subsurf_scattering.glsl');
|
||||
# env.GLES2_GLSL('ssao.glsl');
|
||||
# env.GLES2_GLSL('ssao_minify.glsl');
|
||||
# env.GLES2_GLSL('ssao_blur.glsl');
|
||||
# env.GLES2_GLSL('exposure.glsl');
|
||||
env.GLES2_GLSL('tonemap.glsl');
|
||||
env.GLES2_GLSL("tonemap.glsl")
|
||||
# env.GLES2_GLSL('particles.glsl');
|
||||
env.GLES2_GLSL('lens_distorted.glsl');
|
||||
env.GLES2_GLSL("lens_distorted.glsl")
|
||||
|
|
|
|||
|
|
@ -1,11 +1,11 @@
|
|||
#!/usr/bin/env python
|
||||
|
||||
Import('env')
|
||||
Import("env")
|
||||
|
||||
env_png = env.Clone()
|
||||
|
||||
# Thirdparty source files
|
||||
if env['builtin_libpng']:
|
||||
if env["builtin_libpng"]:
|
||||
thirdparty_dir = "#thirdparty/libpng/"
|
||||
thirdparty_sources = [
|
||||
"png.c",
|
||||
|
|
@ -32,6 +32,7 @@ if env['builtin_libpng']:
|
|||
|
||||
# Currently .ASM filter_neon.S does not compile on NT.
|
||||
import os
|
||||
|
||||
use_neon = "neon_enabled" in env and env["neon_enabled"] and os.name != "nt"
|
||||
if use_neon:
|
||||
env_png.Append(CPPDEFINES=[("PNG_ARM_NEON_OPT", 2)])
|
||||
|
|
@ -45,7 +46,7 @@ if env['builtin_libpng']:
|
|||
if use_neon:
|
||||
env_neon = env_thirdparty.Clone()
|
||||
if "S_compiler" in env:
|
||||
env_neon['CC'] = env['S_compiler']
|
||||
env_neon["CC"] = env["S_compiler"]
|
||||
neon_sources = []
|
||||
neon_sources.append(env_neon.Object(thirdparty_dir + "/arm/arm_init.c"))
|
||||
neon_sources.append(env_neon.Object(thirdparty_dir + "/arm/filter_neon_intrinsics.c"))
|
||||
|
|
@ -56,4 +57,4 @@ if env['builtin_libpng']:
|
|||
# Godot source files
|
||||
env_png.add_source_files(env.drivers_sources, "*.cpp")
|
||||
|
||||
Export('env')
|
||||
Export("env")
|
||||
|
|
|
|||
|
|
@ -1,5 +1,5 @@
|
|||
#!/usr/bin/env python
|
||||
|
||||
Import('env')
|
||||
Import("env")
|
||||
|
||||
env.add_source_files(env.drivers_sources, "*.cpp")
|
||||
|
|
|
|||
|
|
@ -1,17 +1,17 @@
|
|||
#!/usr/bin/env python
|
||||
|
||||
Import('env')
|
||||
Import("env")
|
||||
|
||||
env_spirv_reflect = env.Clone()
|
||||
env_spirv_reflect.disable_warnings()
|
||||
|
||||
thirdparty_dir = "#thirdparty/spirv-reflect/"
|
||||
thirdparty_sources = [
|
||||
"spirv_reflect.c"
|
||||
"spirv_reflect.c",
|
||||
]
|
||||
|
||||
thirdparty_sources = [thirdparty_dir + file for file in thirdparty_sources]
|
||||
|
||||
env_spirv_reflect.add_source_files(env.drivers_sources, thirdparty_sources)
|
||||
|
||||
Export('env')
|
||||
Export("env")
|
||||
|
|
|
|||
|
|
@ -1,6 +1,6 @@
|
|||
#!/usr/bin/env python
|
||||
|
||||
Import('env')
|
||||
Import("env")
|
||||
|
||||
env.add_source_files(env.drivers_sources, "*.cpp")
|
||||
|
||||
|
|
|
|||
|
|
@ -1,10 +1,10 @@
|
|||
#!/usr/bin/env python
|
||||
|
||||
Import('env')
|
||||
Import("env")
|
||||
|
||||
env.add_source_files(env.drivers_sources, "*.cpp")
|
||||
|
||||
if env['builtin_vulkan']:
|
||||
if env["builtin_vulkan"]:
|
||||
# Use bundled Vulkan headers
|
||||
thirdparty_dir = "#thirdparty/vulkan"
|
||||
env.Prepend(CPPPATH=[thirdparty_dir, thirdparty_dir + "/include", thirdparty_dir + "/loader"])
|
||||
|
|
@ -27,48 +27,56 @@ if env['builtin_vulkan']:
|
|||
]
|
||||
vma_sources = [thirdparty_dir + "/vk_mem_alloc.cpp"]
|
||||
|
||||
if env['platform'] == "windows":
|
||||
if env["platform"] == "windows":
|
||||
loader_sources.append("dirent_on_windows.c")
|
||||
loader_sources.append("dxgi_loader.c")
|
||||
env_thirdparty.AppendUnique(CPPDEFINES=[
|
||||
'VK_USE_PLATFORM_WIN32_KHR',
|
||||
'VULKAN_NON_CMAKE_BUILD',
|
||||
'WIN32_LEAN_AND_MEAN',
|
||||
'API_NAME=\\"%s\\"' % 'Vulkan'
|
||||
])
|
||||
env_thirdparty.AppendUnique(
|
||||
CPPDEFINES=[
|
||||
"VK_USE_PLATFORM_WIN32_KHR",
|
||||
"VULKAN_NON_CMAKE_BUILD",
|
||||
"WIN32_LEAN_AND_MEAN",
|
||||
'API_NAME=\\"%s\\"' % "Vulkan",
|
||||
]
|
||||
)
|
||||
if not env.msvc: # Windows 7+, missing in mingw headers
|
||||
env_thirdparty.AppendUnique(CPPDEFINES=[
|
||||
"CM_GETIDLIST_FILTER_CLASS=0x00000200",
|
||||
"CM_GETIDLIST_FILTER_PRESENT=0x00000100"
|
||||
])
|
||||
elif env['platform'] == "osx":
|
||||
env_thirdparty.AppendUnique(CPPDEFINES=[
|
||||
'VK_USE_PLATFORM_MACOS_MVK',
|
||||
'VULKAN_NON_CMAKE_BUILD',
|
||||
'SYSCONFDIR=\\"%s\\"' % '/etc',
|
||||
'FALLBACK_DATA_DIRS=\\"%s\\"' % '/usr/local/share:/usr/share',
|
||||
'FALLBACK_CONFIG_DIRS=\\"%s\\"' % '/etc/xdg'
|
||||
])
|
||||
elif env['platform'] == "iphone":
|
||||
env_thirdparty.AppendUnique(CPPDEFINES=[
|
||||
'VK_USE_PLATFORM_IOS_MVK',
|
||||
'VULKAN_NON_CMAKE_BUILD',
|
||||
'SYSCONFDIR=\\"%s\\"' % '/etc',
|
||||
'FALLBACK_DATA_DIRS=\\"%s\\"' % '/usr/local/share:/usr/share',
|
||||
'FALLBACK_CONFIG_DIRS=\\"%s\\"' % '/etc/xdg'
|
||||
])
|
||||
elif env['platform'] == "linuxbsd":
|
||||
env_thirdparty.AppendUnique(CPPDEFINES=[
|
||||
'VK_USE_PLATFORM_XLIB_KHR',
|
||||
'VULKAN_NON_CMAKE_BUILD',
|
||||
'SYSCONFDIR=\\"%s\\"' % '/etc',
|
||||
'FALLBACK_DATA_DIRS=\\"%s\\"' % '/usr/local/share:/usr/share',
|
||||
'FALLBACK_CONFIG_DIRS=\\"%s\\"' % '/etc/xdg'
|
||||
])
|
||||
env_thirdparty.AppendUnique(
|
||||
CPPDEFINES=["CM_GETIDLIST_FILTER_CLASS=0x00000200", "CM_GETIDLIST_FILTER_PRESENT=0x00000100"]
|
||||
)
|
||||
elif env["platform"] == "osx":
|
||||
env_thirdparty.AppendUnique(
|
||||
CPPDEFINES=[
|
||||
"VK_USE_PLATFORM_MACOS_MVK",
|
||||
"VULKAN_NON_CMAKE_BUILD",
|
||||
'SYSCONFDIR=\\"%s\\"' % "/etc",
|
||||
'FALLBACK_DATA_DIRS=\\"%s\\"' % "/usr/local/share:/usr/share",
|
||||
'FALLBACK_CONFIG_DIRS=\\"%s\\"' % "/etc/xdg",
|
||||
]
|
||||
)
|
||||
elif env["platform"] == "iphone":
|
||||
env_thirdparty.AppendUnique(
|
||||
CPPDEFINES=[
|
||||
"VK_USE_PLATFORM_IOS_MVK",
|
||||
"VULKAN_NON_CMAKE_BUILD",
|
||||
'SYSCONFDIR=\\"%s\\"' % "/etc",
|
||||
'FALLBACK_DATA_DIRS=\\"%s\\"' % "/usr/local/share:/usr/share",
|
||||
'FALLBACK_CONFIG_DIRS=\\"%s\\"' % "/etc/xdg",
|
||||
]
|
||||
)
|
||||
elif env["platform"] == "linuxbsd":
|
||||
env_thirdparty.AppendUnique(
|
||||
CPPDEFINES=[
|
||||
"VK_USE_PLATFORM_XLIB_KHR",
|
||||
"VULKAN_NON_CMAKE_BUILD",
|
||||
'SYSCONFDIR=\\"%s\\"' % "/etc",
|
||||
'FALLBACK_DATA_DIRS=\\"%s\\"' % "/usr/local/share:/usr/share",
|
||||
'FALLBACK_CONFIG_DIRS=\\"%s\\"' % "/etc/xdg",
|
||||
]
|
||||
)
|
||||
import platform
|
||||
if (platform.system() == "Linux"):
|
||||
|
||||
if platform.system() == "Linux":
|
||||
# In glibc since 2.17 and musl libc since 1.1.24. Used by loader.c.
|
||||
env_thirdparty.AppendUnique(CPPDEFINES=['HAVE_SECURE_GETENV'])
|
||||
env_thirdparty.AppendUnique(CPPDEFINES=["HAVE_SECURE_GETENV"])
|
||||
|
||||
loader_sources = [thirdparty_dir + "/loader/" + file for file in loader_sources]
|
||||
env_thirdparty.add_source_files(env.drivers_sources, loader_sources)
|
||||
|
|
|
|||
|
|
@ -1,6 +1,6 @@
|
|||
#!/usr/bin/env python
|
||||
|
||||
Import('env')
|
||||
Import("env")
|
||||
|
||||
# Driver source files
|
||||
env.add_source_files(env.drivers_sources, "*.cpp")
|
||||
|
|
|
|||
|
|
@ -1,5 +1,5 @@
|
|||
#!/usr/bin/env python
|
||||
|
||||
Import('env')
|
||||
Import("env")
|
||||
|
||||
env.add_source_files(env.drivers_sources, "*.cpp")
|
||||
|
|
|
|||
|
|
@ -1,6 +1,6 @@
|
|||
#!/usr/bin/env python
|
||||
|
||||
Import('env')
|
||||
Import("env")
|
||||
|
||||
# Driver source files
|
||||
env.add_source_files(env.drivers_sources, "*.cpp")
|
||||
|
|
|
|||
|
|
@ -1,7 +1,7 @@
|
|||
#!/usr/bin/env python
|
||||
|
||||
Import('env')
|
||||
Import("env")
|
||||
|
||||
env.add_source_files(env.drivers_sources, "*.cpp")
|
||||
env.Append(CPPDEFINES=['XAUDIO2_ENABLED'])
|
||||
env.Append(LINKFLAGS=['xaudio2_8.lib'])
|
||||
env.Append(CPPDEFINES=["XAUDIO2_ENABLED"])
|
||||
env.Append(LINKFLAGS=["xaudio2_8.lib"])
|
||||
|
|
|
|||
46
editor/SCsub
46
editor/SCsub
|
|
@ -1,6 +1,6 @@
|
|||
#!/usr/bin/env python
|
||||
|
||||
Import('env')
|
||||
Import("env")
|
||||
|
||||
env.editor_sources = []
|
||||
|
||||
|
|
@ -16,24 +16,24 @@ def _make_doc_data_class_path(to_path):
|
|||
g.write("static const int _doc_data_class_path_count = " + str(len(env.doc_class_path)) + ";\n")
|
||||
g.write("struct _DocDataClassPath { const char* name; const char* path; };\n")
|
||||
|
||||
g.write("static const _DocDataClassPath _doc_data_class_paths[" + str(len(env.doc_class_path) + 1) + "] = {\n");
|
||||
g.write("static const _DocDataClassPath _doc_data_class_paths[" + str(len(env.doc_class_path) + 1) + "] = {\n")
|
||||
for c in sorted(env.doc_class_path):
|
||||
g.write("\t{\"" + c + "\", \"" + env.doc_class_path[c] + "\"},\n")
|
||||
g.write('\t{"' + c + '", "' + env.doc_class_path[c] + '"},\n')
|
||||
g.write("\t{NULL, NULL}\n")
|
||||
g.write("};\n")
|
||||
|
||||
g.close()
|
||||
|
||||
|
||||
if env['tools']:
|
||||
if env["tools"]:
|
||||
# Register exporters
|
||||
reg_exporters_inc = '#include "register_exporters.h"\n'
|
||||
reg_exporters = 'void register_exporters() {\n'
|
||||
reg_exporters = "void register_exporters() {\n"
|
||||
for e in env.platform_exporters:
|
||||
env.add_source_files(env.editor_sources, "#platform/" + e + "/export/export.cpp")
|
||||
reg_exporters += '\tregister_' + e + '_exporter();\n'
|
||||
reg_exporters += "\tregister_" + e + "_exporter();\n"
|
||||
reg_exporters_inc += '#include "platform/' + e + '/export/export.h"\n'
|
||||
reg_exporters += '}\n'
|
||||
reg_exporters += "}\n"
|
||||
|
||||
# NOTE: It is safe to generate this file here, since this is still executed serially
|
||||
with open("register_exporters.gen.cpp", "w", encoding="utf-8") as f:
|
||||
|
|
@ -50,12 +50,12 @@ if env['tools']:
|
|||
|
||||
for d in doc_dirs:
|
||||
try:
|
||||
for f in os.listdir(os.path.join(env.Dir('#').abspath, d)):
|
||||
for f in os.listdir(os.path.join(env.Dir("#").abspath, d)):
|
||||
docs.append("#" + os.path.join(d, f))
|
||||
except OSError:
|
||||
pass
|
||||
|
||||
_make_doc_data_class_path(os.path.join(env.Dir('#').abspath, "editor"))
|
||||
_make_doc_data_class_path(os.path.join(env.Dir("#").abspath, "editor"))
|
||||
|
||||
docs = sorted(docs)
|
||||
env.Depends("#editor/doc_data_compressed.gen.h", docs)
|
||||
|
|
@ -63,32 +63,36 @@ if env['tools']:
|
|||
|
||||
import glob
|
||||
|
||||
path = env.Dir('.').abspath
|
||||
path = env.Dir(".").abspath
|
||||
|
||||
# Editor translations
|
||||
tlist = glob.glob(path + "/translations/*.po")
|
||||
env.Depends('#editor/editor_translations.gen.h', tlist)
|
||||
env.CommandNoCache('#editor/editor_translations.gen.h', tlist, run_in_subprocess(editor_builders.make_editor_translations_header))
|
||||
env.Depends("#editor/editor_translations.gen.h", tlist)
|
||||
env.CommandNoCache(
|
||||
"#editor/editor_translations.gen.h", tlist, run_in_subprocess(editor_builders.make_editor_translations_header)
|
||||
)
|
||||
|
||||
# Documentation translations
|
||||
tlist = glob.glob(env.Dir("#doc").abspath + "/translations/*.po")
|
||||
env.Depends('#editor/doc_translations.gen.h', tlist)
|
||||
env.CommandNoCache('#editor/doc_translations.gen.h', tlist, run_in_subprocess(editor_builders.make_doc_translations_header))
|
||||
env.Depends("#editor/doc_translations.gen.h", tlist)
|
||||
env.CommandNoCache(
|
||||
"#editor/doc_translations.gen.h", tlist, run_in_subprocess(editor_builders.make_doc_translations_header)
|
||||
)
|
||||
|
||||
# Fonts
|
||||
flist = glob.glob(path + "/../thirdparty/fonts/*.ttf")
|
||||
flist.extend(glob.glob(path + "/../thirdparty/fonts/*.otf"))
|
||||
flist.sort()
|
||||
env.Depends('#editor/builtin_fonts.gen.h', flist)
|
||||
env.CommandNoCache('#editor/builtin_fonts.gen.h', flist, run_in_subprocess(editor_builders.make_fonts_header))
|
||||
env.Depends("#editor/builtin_fonts.gen.h", flist)
|
||||
env.CommandNoCache("#editor/builtin_fonts.gen.h", flist, run_in_subprocess(editor_builders.make_fonts_header))
|
||||
|
||||
env.add_source_files(env.editor_sources, "*.cpp")
|
||||
|
||||
SConscript('debugger/SCsub')
|
||||
SConscript('fileserver/SCsub')
|
||||
SConscript('icons/SCsub')
|
||||
SConscript('import/SCsub')
|
||||
SConscript('plugins/SCsub')
|
||||
SConscript("debugger/SCsub")
|
||||
SConscript("fileserver/SCsub")
|
||||
SConscript("icons/SCsub")
|
||||
SConscript("import/SCsub")
|
||||
SConscript("plugins/SCsub")
|
||||
|
||||
lib = env.add_library("editor", env.editor_sources)
|
||||
env.Prepend(LIBS=[lib])
|
||||
|
|
|
|||
|
|
@ -1,5 +1,5 @@
|
|||
#!/usr/bin/env python
|
||||
|
||||
Import('env')
|
||||
Import("env")
|
||||
|
||||
env.add_source_files(env.editor_sources, "*.cpp")
|
||||
|
|
|
|||
|
|
@ -25,6 +25,7 @@ def make_doc_header(target, source, env):
|
|||
buf = (docbegin + buf + docend).encode("utf-8")
|
||||
decomp_size = len(buf)
|
||||
import zlib
|
||||
|
||||
buf = zlib.compress(buf)
|
||||
|
||||
g.write("/* THIS FILE IS GENERATED DO NOT EDIT */\n")
|
||||
|
|
@ -111,7 +112,9 @@ def make_translations_header(target, source, env, category):
|
|||
g.write("};\n\n")
|
||||
g.write("static {}TranslationList _{}_translations[] = {{\n".format(category.capitalize(), category))
|
||||
for x in xl_names:
|
||||
g.write("\t{{ \"{}\", {}, {}, _{}_translation_{}_compressed }},\n".format(x[0], str(x[1]), str(x[2]), category, x[0]))
|
||||
g.write(
|
||||
'\t{{ "{}", {}, {}, _{}_translation_{}_compressed }},\n'.format(x[0], str(x[1]), str(x[2]), category, x[0])
|
||||
)
|
||||
g.write("\t{NULL, 0, 0, NULL}\n")
|
||||
g.write("};\n")
|
||||
|
||||
|
|
@ -128,5 +131,5 @@ def make_doc_translations_header(target, source, env):
|
|||
make_translations_header(target, source, env, "doc")
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
if __name__ == "__main__":
|
||||
subprocess_main(globals())
|
||||
|
|
|
|||
|
|
@ -1,5 +1,5 @@
|
|||
#!/usr/bin/env python
|
||||
|
||||
Import('env')
|
||||
Import("env")
|
||||
|
||||
env.add_source_files(env.editor_sources, "*.cpp")
|
||||
|
|
|
|||
|
|
@ -1,21 +1,21 @@
|
|||
#!/usr/bin/env python
|
||||
|
||||
Import('env')
|
||||
Import("env")
|
||||
|
||||
from platform_methods import run_in_subprocess
|
||||
import editor_icons_builders
|
||||
|
||||
make_editor_icons_builder = Builder(action=run_in_subprocess(editor_icons_builders.make_editor_icons_action),
|
||||
suffix='.h',
|
||||
src_suffix='.svg')
|
||||
make_editor_icons_builder = Builder(
|
||||
action=run_in_subprocess(editor_icons_builders.make_editor_icons_action), suffix=".h", src_suffix=".svg"
|
||||
)
|
||||
|
||||
env['BUILDERS']['MakeEditorIconsBuilder'] = make_editor_icons_builder
|
||||
env["BUILDERS"]["MakeEditorIconsBuilder"] = make_editor_icons_builder
|
||||
|
||||
# Editor's own icons
|
||||
icon_sources = Glob("*.svg")
|
||||
|
||||
# Module icons
|
||||
for module_icons in env.module_icons_paths:
|
||||
icon_sources += Glob('#' + module_icons + "/*.svg")
|
||||
icon_sources += Glob("#" + module_icons + "/*.svg")
|
||||
|
||||
env.Alias('editor_icons', [env.MakeEditorIconsBuilder('#editor/editor_icons.gen.h', icon_sources)])
|
||||
env.Alias("editor_icons", [env.MakeEditorIconsBuilder("#editor/editor_icons.gen.h", icon_sources)])
|
||||
|
|
|
|||
|
|
@ -22,16 +22,16 @@ def make_editor_icons_action(target, source, env):
|
|||
|
||||
icons_string.write('\t"')
|
||||
|
||||
with open(fname, 'rb') as svgf:
|
||||
with open(fname, "rb") as svgf:
|
||||
b = svgf.read(1)
|
||||
while(len(b) == 1):
|
||||
while len(b) == 1:
|
||||
icons_string.write("\\" + str(hex(ord(b)))[1:])
|
||||
b = svgf.read(1)
|
||||
|
||||
icons_string.write('"')
|
||||
if fname != svg_icons[-1]:
|
||||
icons_string.write(",")
|
||||
icons_string.write('\n')
|
||||
icons_string.write("\n")
|
||||
|
||||
s = StringIO()
|
||||
s.write("/* THIS FILE IS GENERATED DO NOT EDIT */\n")
|
||||
|
|
@ -40,7 +40,7 @@ def make_editor_icons_action(target, source, env):
|
|||
s.write("static const int editor_icons_count = {};\n".format(len(svg_icons)))
|
||||
s.write("static const char *editor_icons_sources[] = {\n")
|
||||
s.write(icons_string.getvalue())
|
||||
s.write('};\n\n')
|
||||
s.write("};\n\n")
|
||||
s.write("static const char *editor_icons_names[] = {\n")
|
||||
|
||||
# this is used to store the indices of thumbnail icons
|
||||
|
|
@ -63,11 +63,11 @@ def make_editor_icons_action(target, source, env):
|
|||
|
||||
if fname != svg_icons[-1]:
|
||||
s.write(",")
|
||||
s.write('\n')
|
||||
s.write("\n")
|
||||
|
||||
index += 1
|
||||
|
||||
s.write('};\n')
|
||||
s.write("};\n")
|
||||
|
||||
if thumb_medium_indices:
|
||||
s.write("\n\n")
|
||||
|
|
@ -91,5 +91,5 @@ def make_editor_icons_action(target, source, env):
|
|||
icons_string.close()
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
if __name__ == "__main__":
|
||||
subprocess_main(globals())
|
||||
|
|
|
|||
|
|
@ -1,5 +1,5 @@
|
|||
#!/usr/bin/env python
|
||||
|
||||
Import('env')
|
||||
Import("env")
|
||||
|
||||
env.add_source_files(env.editor_sources, "*.cpp")
|
||||
|
|
|
|||
|
|
@ -1,5 +1,5 @@
|
|||
#!/usr/bin/env python
|
||||
|
||||
Import('env')
|
||||
Import("env")
|
||||
|
||||
env.add_source_files(env.editor_sources, "*.cpp")
|
||||
|
|
|
|||
|
|
@ -10,23 +10,23 @@ import sys
|
|||
line_nb = False
|
||||
|
||||
for arg in sys.argv[1:]:
|
||||
if (arg == "--with-line-nb"):
|
||||
if arg == "--with-line-nb":
|
||||
print("Enabling line numbers in the context locations.")
|
||||
line_nb = True
|
||||
else:
|
||||
os.sys.exit("Non supported argument '" + arg + "'. Aborting.")
|
||||
|
||||
|
||||
if (not os.path.exists("editor")):
|
||||
if not os.path.exists("editor"):
|
||||
os.sys.exit("ERROR: This script should be started from the root of the git repo.")
|
||||
|
||||
|
||||
matches = []
|
||||
for root, dirnames, filenames in os.walk('.'):
|
||||
for root, dirnames, filenames in os.walk("."):
|
||||
dirnames[:] = [d for d in dirnames if d not in ["thirdparty"]]
|
||||
for filename in fnmatch.filter(filenames, '*.cpp'):
|
||||
for filename in fnmatch.filter(filenames, "*.cpp"):
|
||||
matches.append(os.path.join(root, filename))
|
||||
for filename in fnmatch.filter(filenames, '*.h'):
|
||||
for filename in fnmatch.filter(filenames, "*.h"):
|
||||
matches.append(os.path.join(root, filename))
|
||||
matches.sort()
|
||||
|
||||
|
|
@ -51,52 +51,54 @@ msgstr ""
|
|||
"Content-Transfer-Encoding: 8-bit\\n"
|
||||
"""
|
||||
|
||||
|
||||
def process_file(f, fname):
|
||||
|
||||
global main_po, unique_str, unique_loc
|
||||
|
||||
l = f.readline()
|
||||
lc = 1
|
||||
while (l):
|
||||
while l:
|
||||
|
||||
patterns = ['RTR(\"', 'TTR(\"', 'TTRC(\"']
|
||||
patterns = ['RTR("', 'TTR("', 'TTRC("']
|
||||
idx = 0
|
||||
pos = 0
|
||||
while (pos >= 0):
|
||||
while pos >= 0:
|
||||
pos = l.find(patterns[idx], pos)
|
||||
if (pos == -1):
|
||||
if (idx < len(patterns) - 1):
|
||||
if pos == -1:
|
||||
if idx < len(patterns) - 1:
|
||||
idx += 1
|
||||
pos = 0
|
||||
continue
|
||||
pos += len(patterns[idx])
|
||||
|
||||
msg = ""
|
||||
while (pos < len(l) and (l[pos] != '"' or l[pos - 1] == '\\')):
|
||||
while pos < len(l) and (l[pos] != '"' or l[pos - 1] == "\\"):
|
||||
msg += l[pos]
|
||||
pos += 1
|
||||
|
||||
location = os.path.relpath(fname).replace('\\', '/')
|
||||
if (line_nb):
|
||||
location = os.path.relpath(fname).replace("\\", "/")
|
||||
if line_nb:
|
||||
location += ":" + str(lc)
|
||||
|
||||
if (not msg in unique_str):
|
||||
if not msg in unique_str:
|
||||
main_po += "\n#: " + location + "\n"
|
||||
main_po += 'msgid "' + msg + '"\n'
|
||||
main_po += 'msgstr ""\n'
|
||||
unique_str.append(msg)
|
||||
unique_loc[msg] = [location]
|
||||
elif (not location in unique_loc[msg]):
|
||||
elif not location in unique_loc[msg]:
|
||||
# Add additional location to previous occurrence too
|
||||
msg_pos = main_po.find('\nmsgid "' + msg + '"')
|
||||
if (msg_pos == -1):
|
||||
if msg_pos == -1:
|
||||
print("Someone apparently thought writing Python was as easy as GDScript. Ping Akien.")
|
||||
main_po = main_po[:msg_pos] + ' ' + location + main_po[msg_pos:]
|
||||
main_po = main_po[:msg_pos] + " " + location + main_po[msg_pos:]
|
||||
unique_loc[msg].append(location)
|
||||
|
||||
l = f.readline()
|
||||
lc += 1
|
||||
|
||||
|
||||
print("Updating the editor.pot template...")
|
||||
|
||||
for fname in matches:
|
||||
|
|
@ -106,7 +108,7 @@ for fname in matches:
|
|||
with open("editor.pot", "w") as f:
|
||||
f.write(main_po)
|
||||
|
||||
if (os.name == "posix"):
|
||||
if os.name == "posix":
|
||||
print("Wrapping template at 79 characters for compatibility with Weblate.")
|
||||
os.system("msgmerge -w79 editor.pot editor.pot > editor.pot.wrap")
|
||||
shutil.move("editor.pot.wrap", "editor.pot")
|
||||
|
|
@ -114,7 +116,7 @@ if (os.name == "posix"):
|
|||
shutil.move("editor.pot", "editor/translations/editor.pot")
|
||||
|
||||
# TODO: Make that in a portable way, if we care; if not, kudos to Unix users
|
||||
if (os.name == "posix"):
|
||||
if os.name == "posix":
|
||||
added = subprocess.check_output(r"git diff editor/translations/editor.pot | grep \+msgid | wc -l", shell=True)
|
||||
removed = subprocess.check_output(r"git diff editor/translations/editor.pot | grep \\\-msgid | wc -l", shell=True)
|
||||
print("\n# Template changes compared to the staged status:")
|
||||
|
|
|
|||
214
gles_builders.py
214
gles_builders.py
|
|
@ -7,7 +7,6 @@ from platform_methods import subprocess_main
|
|||
|
||||
|
||||
class LegacyGLHeaderStruct:
|
||||
|
||||
def __init__(self):
|
||||
self.vertex_lines = []
|
||||
self.fragment_lines = []
|
||||
|
|
@ -206,11 +205,13 @@ def build_legacygl_header(filename, include, class_suffix, output_attribs, gles2
|
|||
fd.write("#ifndef " + out_file_ifdef + class_suffix + "_120\n")
|
||||
fd.write("#define " + out_file_ifdef + class_suffix + "_120\n")
|
||||
|
||||
out_file_class = out_file_base.replace(".glsl.gen.h", "").title().replace("_", "").replace(".", "") + "Shader" + class_suffix
|
||||
out_file_class = (
|
||||
out_file_base.replace(".glsl.gen.h", "").title().replace("_", "").replace(".", "") + "Shader" + class_suffix
|
||||
)
|
||||
fd.write("\n\n")
|
||||
fd.write("#include \"" + include + "\"\n\n\n")
|
||||
fd.write('#include "' + include + '"\n\n\n')
|
||||
fd.write("class " + out_file_class + " : public Shader" + class_suffix + " {\n\n")
|
||||
fd.write("\t virtual String get_shader_name() const { return \"" + out_file_class + "\"; }\n")
|
||||
fd.write('\t virtual String get_shader_name() const { return "' + out_file_class + '"; }\n')
|
||||
|
||||
fd.write("public:\n\n")
|
||||
|
||||
|
|
@ -228,29 +229,64 @@ def build_legacygl_header(filename, include, class_suffix, output_attribs, gles2
|
|||
|
||||
fd.write("\t_FORCE_INLINE_ int get_uniform(Uniforms p_uniform) const { return _get_uniform(p_uniform); }\n\n")
|
||||
if header_data.conditionals:
|
||||
fd.write("\t_FORCE_INLINE_ void set_conditional(Conditionals p_conditional,bool p_enable) { _set_conditional(p_conditional,p_enable); }\n\n")
|
||||
fd.write(
|
||||
"\t_FORCE_INLINE_ void set_conditional(Conditionals p_conditional,bool p_enable) { _set_conditional(p_conditional,p_enable); }\n\n"
|
||||
)
|
||||
fd.write("\t#ifdef DEBUG_ENABLED\n ")
|
||||
fd.write("\t#define _FU if (get_uniform(p_uniform)<0) return; if (!is_version_valid()) return; ERR_FAIL_COND( get_active()!=this ); \n\n ")
|
||||
fd.write(
|
||||
"\t#define _FU if (get_uniform(p_uniform)<0) return; if (!is_version_valid()) return; ERR_FAIL_COND( get_active()!=this ); \n\n "
|
||||
)
|
||||
fd.write("\t#else\n ")
|
||||
fd.write("\t#define _FU if (get_uniform(p_uniform)<0) return; \n\n ")
|
||||
fd.write("\t#endif\n")
|
||||
fd.write("\t_FORCE_INLINE_ void set_uniform(Uniforms p_uniform, float p_value) { _FU glUniform1f(get_uniform(p_uniform),p_value); }\n\n")
|
||||
fd.write("\t_FORCE_INLINE_ void set_uniform(Uniforms p_uniform, double p_value) { _FU glUniform1f(get_uniform(p_uniform),p_value); }\n\n")
|
||||
fd.write("\t_FORCE_INLINE_ void set_uniform(Uniforms p_uniform, uint8_t p_value) { _FU glUniform1i(get_uniform(p_uniform),p_value); }\n\n")
|
||||
fd.write("\t_FORCE_INLINE_ void set_uniform(Uniforms p_uniform, int8_t p_value) { _FU glUniform1i(get_uniform(p_uniform),p_value); }\n\n")
|
||||
fd.write("\t_FORCE_INLINE_ void set_uniform(Uniforms p_uniform, uint16_t p_value) { _FU glUniform1i(get_uniform(p_uniform),p_value); }\n\n")
|
||||
fd.write("\t_FORCE_INLINE_ void set_uniform(Uniforms p_uniform, int16_t p_value) { _FU glUniform1i(get_uniform(p_uniform),p_value); }\n\n")
|
||||
fd.write("\t_FORCE_INLINE_ void set_uniform(Uniforms p_uniform, uint32_t p_value) { _FU glUniform1i(get_uniform(p_uniform),p_value); }\n\n")
|
||||
fd.write("\t_FORCE_INLINE_ void set_uniform(Uniforms p_uniform, int32_t p_value) { _FU glUniform1i(get_uniform(p_uniform),p_value); }\n\n")
|
||||
fd.write("\t_FORCE_INLINE_ void set_uniform(Uniforms p_uniform, const Color& p_color) { _FU GLfloat col[4]={p_color.r,p_color.g,p_color.b,p_color.a}; glUniform4fv(get_uniform(p_uniform),1,col); }\n\n")
|
||||
fd.write("\t_FORCE_INLINE_ void set_uniform(Uniforms p_uniform, const Vector2& p_vec2) { _FU GLfloat vec2[2]={p_vec2.x,p_vec2.y}; glUniform2fv(get_uniform(p_uniform),1,vec2); }\n\n")
|
||||
fd.write("\t_FORCE_INLINE_ void set_uniform(Uniforms p_uniform, const Size2i& p_vec2) { _FU GLint vec2[2]={p_vec2.x,p_vec2.y}; glUniform2iv(get_uniform(p_uniform),1,vec2); }\n\n")
|
||||
fd.write("\t_FORCE_INLINE_ void set_uniform(Uniforms p_uniform, const Vector3& p_vec3) { _FU GLfloat vec3[3]={p_vec3.x,p_vec3.y,p_vec3.z}; glUniform3fv(get_uniform(p_uniform),1,vec3); }\n\n")
|
||||
fd.write("\t_FORCE_INLINE_ void set_uniform(Uniforms p_uniform, float p_a, float p_b) { _FU glUniform2f(get_uniform(p_uniform),p_a,p_b); }\n\n")
|
||||
fd.write("\t_FORCE_INLINE_ void set_uniform(Uniforms p_uniform, float p_a, float p_b, float p_c) { _FU glUniform3f(get_uniform(p_uniform),p_a,p_b,p_c); }\n\n")
|
||||
fd.write("\t_FORCE_INLINE_ void set_uniform(Uniforms p_uniform, float p_a, float p_b, float p_c, float p_d) { _FU glUniform4f(get_uniform(p_uniform),p_a,p_b,p_c,p_d); }\n\n")
|
||||
fd.write(
|
||||
"\t_FORCE_INLINE_ void set_uniform(Uniforms p_uniform, float p_value) { _FU glUniform1f(get_uniform(p_uniform),p_value); }\n\n"
|
||||
)
|
||||
fd.write(
|
||||
"\t_FORCE_INLINE_ void set_uniform(Uniforms p_uniform, double p_value) { _FU glUniform1f(get_uniform(p_uniform),p_value); }\n\n"
|
||||
)
|
||||
fd.write(
|
||||
"\t_FORCE_INLINE_ void set_uniform(Uniforms p_uniform, uint8_t p_value) { _FU glUniform1i(get_uniform(p_uniform),p_value); }\n\n"
|
||||
)
|
||||
fd.write(
|
||||
"\t_FORCE_INLINE_ void set_uniform(Uniforms p_uniform, int8_t p_value) { _FU glUniform1i(get_uniform(p_uniform),p_value); }\n\n"
|
||||
)
|
||||
fd.write(
|
||||
"\t_FORCE_INLINE_ void set_uniform(Uniforms p_uniform, uint16_t p_value) { _FU glUniform1i(get_uniform(p_uniform),p_value); }\n\n"
|
||||
)
|
||||
fd.write(
|
||||
"\t_FORCE_INLINE_ void set_uniform(Uniforms p_uniform, int16_t p_value) { _FU glUniform1i(get_uniform(p_uniform),p_value); }\n\n"
|
||||
)
|
||||
fd.write(
|
||||
"\t_FORCE_INLINE_ void set_uniform(Uniforms p_uniform, uint32_t p_value) { _FU glUniform1i(get_uniform(p_uniform),p_value); }\n\n"
|
||||
)
|
||||
fd.write(
|
||||
"\t_FORCE_INLINE_ void set_uniform(Uniforms p_uniform, int32_t p_value) { _FU glUniform1i(get_uniform(p_uniform),p_value); }\n\n"
|
||||
)
|
||||
fd.write(
|
||||
"\t_FORCE_INLINE_ void set_uniform(Uniforms p_uniform, const Color& p_color) { _FU GLfloat col[4]={p_color.r,p_color.g,p_color.b,p_color.a}; glUniform4fv(get_uniform(p_uniform),1,col); }\n\n"
|
||||
)
|
||||
fd.write(
|
||||
"\t_FORCE_INLINE_ void set_uniform(Uniforms p_uniform, const Vector2& p_vec2) { _FU GLfloat vec2[2]={p_vec2.x,p_vec2.y}; glUniform2fv(get_uniform(p_uniform),1,vec2); }\n\n"
|
||||
)
|
||||
fd.write(
|
||||
"\t_FORCE_INLINE_ void set_uniform(Uniforms p_uniform, const Size2i& p_vec2) { _FU GLint vec2[2]={p_vec2.x,p_vec2.y}; glUniform2iv(get_uniform(p_uniform),1,vec2); }\n\n"
|
||||
)
|
||||
fd.write(
|
||||
"\t_FORCE_INLINE_ void set_uniform(Uniforms p_uniform, const Vector3& p_vec3) { _FU GLfloat vec3[3]={p_vec3.x,p_vec3.y,p_vec3.z}; glUniform3fv(get_uniform(p_uniform),1,vec3); }\n\n"
|
||||
)
|
||||
fd.write(
|
||||
"\t_FORCE_INLINE_ void set_uniform(Uniforms p_uniform, float p_a, float p_b) { _FU glUniform2f(get_uniform(p_uniform),p_a,p_b); }\n\n"
|
||||
)
|
||||
fd.write(
|
||||
"\t_FORCE_INLINE_ void set_uniform(Uniforms p_uniform, float p_a, float p_b, float p_c) { _FU glUniform3f(get_uniform(p_uniform),p_a,p_b,p_c); }\n\n"
|
||||
)
|
||||
fd.write(
|
||||
"\t_FORCE_INLINE_ void set_uniform(Uniforms p_uniform, float p_a, float p_b, float p_c, float p_d) { _FU glUniform4f(get_uniform(p_uniform),p_a,p_b,p_c,p_d); }\n\n"
|
||||
)
|
||||
|
||||
fd.write("""\t_FORCE_INLINE_ void set_uniform(Uniforms p_uniform, const Transform& p_transform) { _FU
|
||||
fd.write(
|
||||
"""\t_FORCE_INLINE_ void set_uniform(Uniforms p_uniform, const Transform& p_transform) { _FU
|
||||
|
||||
const Transform &tr = p_transform;
|
||||
|
||||
|
|
@ -276,9 +312,11 @@ def build_legacygl_header(filename, include, class_suffix, output_attribs, gles2
|
|||
glUniformMatrix4fv(get_uniform(p_uniform),1,false,matrix);
|
||||
}
|
||||
|
||||
""")
|
||||
"""
|
||||
)
|
||||
|
||||
fd.write("""_FORCE_INLINE_ void set_uniform(Uniforms p_uniform, const Transform2D& p_transform) { _FU
|
||||
fd.write(
|
||||
"""_FORCE_INLINE_ void set_uniform(Uniforms p_uniform, const Transform2D& p_transform) { _FU
|
||||
|
||||
const Transform2D &tr = p_transform;
|
||||
|
||||
|
|
@ -304,9 +342,11 @@ def build_legacygl_header(filename, include, class_suffix, output_attribs, gles2
|
|||
glUniformMatrix4fv(get_uniform(p_uniform),1,false,matrix);
|
||||
}
|
||||
|
||||
""")
|
||||
"""
|
||||
)
|
||||
|
||||
fd.write("""_FORCE_INLINE_ void set_uniform(Uniforms p_uniform, const CameraMatrix& p_matrix) { _FU
|
||||
fd.write(
|
||||
"""_FORCE_INLINE_ void set_uniform(Uniforms p_uniform, const CameraMatrix& p_matrix) { _FU
|
||||
|
||||
GLfloat matrix[16];
|
||||
|
||||
|
|
@ -320,7 +360,8 @@ def build_legacygl_header(filename, include, class_suffix, output_attribs, gles2
|
|||
glUniformMatrix4fv(get_uniform(p_uniform),1,false,matrix);
|
||||
}
|
||||
|
||||
""")
|
||||
"""
|
||||
)
|
||||
|
||||
fd.write("\n\n#undef _FU\n\n\n")
|
||||
|
||||
|
|
@ -340,21 +381,25 @@ def build_legacygl_header(filename, include, class_suffix, output_attribs, gles2
|
|||
x = header_data.enums[xv]
|
||||
bits = 1
|
||||
amt = len(x)
|
||||
while (2 ** bits < amt):
|
||||
while 2 ** bits < amt:
|
||||
bits += 1
|
||||
strs = "{"
|
||||
for i in range(amt):
|
||||
strs += "\"#define " + x[i] + "\\n\","
|
||||
strs += '"#define ' + x[i] + '\\n",'
|
||||
|
||||
c = {}
|
||||
c["set_mask"] = "uint64_t(" + str(i) + ")<<" + str(bitofs)
|
||||
c["clear_mask"] = "((uint64_t(1)<<40)-1) ^ (((uint64_t(1)<<" + str(bits) + ") - 1)<<" + str(bitofs) + ")"
|
||||
c["clear_mask"] = (
|
||||
"((uint64_t(1)<<40)-1) ^ (((uint64_t(1)<<" + str(bits) + ") - 1)<<" + str(bitofs) + ")"
|
||||
)
|
||||
enum_vals.append(c)
|
||||
enum_constants.append(x[i])
|
||||
|
||||
strs += "NULL}"
|
||||
|
||||
fd.write("\t\t\t{(uint64_t(1<<" + str(bits) + ")-1)<<" + str(bitofs) + "," + str(bitofs) + "," + strs + "},\n")
|
||||
fd.write(
|
||||
"\t\t\t{(uint64_t(1<<" + str(bits) + ")-1)<<" + str(bitofs) + "," + str(bitofs) + "," + strs + "},\n"
|
||||
)
|
||||
bitofs += bits
|
||||
|
||||
fd.write("\t\t};\n\n")
|
||||
|
|
@ -373,7 +418,7 @@ def build_legacygl_header(filename, include, class_suffix, output_attribs, gles2
|
|||
fd.write("\t\tstatic const char* _conditional_strings[]={\n")
|
||||
if header_data.conditionals:
|
||||
for x in header_data.conditionals:
|
||||
fd.write("\t\t\t\"#define " + x + "\\n\",\n")
|
||||
fd.write('\t\t\t"#define ' + x + '\\n",\n')
|
||||
conditionals_found.append(x)
|
||||
fd.write("\t\t};\n\n")
|
||||
else:
|
||||
|
|
@ -384,7 +429,7 @@ def build_legacygl_header(filename, include, class_suffix, output_attribs, gles2
|
|||
fd.write("\t\tstatic const char* _uniform_strings[]={\n")
|
||||
if header_data.uniforms:
|
||||
for x in header_data.uniforms:
|
||||
fd.write("\t\t\t\"" + x + "\",\n")
|
||||
fd.write('\t\t\t"' + x + '",\n')
|
||||
fd.write("\t\t};\n\n")
|
||||
else:
|
||||
fd.write("\t\tstatic const char **_uniform_strings=NULL;\n")
|
||||
|
|
@ -394,7 +439,7 @@ def build_legacygl_header(filename, include, class_suffix, output_attribs, gles2
|
|||
|
||||
fd.write("\t\tstatic AttributePair _attribute_pairs[]={\n")
|
||||
for x in header_data.attributes:
|
||||
fd.write("\t\t\t{\"" + x[0] + "\"," + x[1] + "},\n")
|
||||
fd.write('\t\t\t{"' + x[0] + '",' + x[1] + "},\n")
|
||||
fd.write("\t\t};\n\n")
|
||||
else:
|
||||
fd.write("\t\tstatic AttributePair *_attribute_pairs=NULL;\n")
|
||||
|
|
@ -408,9 +453,9 @@ def build_legacygl_header(filename, include, class_suffix, output_attribs, gles2
|
|||
name = x[0]
|
||||
cond = x[1]
|
||||
if cond in conditionals_found:
|
||||
fd.write("\t\t\t{\"" + name + "\"," + str(conditionals_found.index(cond)) + "},\n")
|
||||
fd.write('\t\t\t{"' + name + '",' + str(conditionals_found.index(cond)) + "},\n")
|
||||
else:
|
||||
fd.write("\t\t\t{\"" + name + "\",-1},\n")
|
||||
fd.write('\t\t\t{"' + name + '",-1},\n')
|
||||
|
||||
feedback_count += 1
|
||||
|
||||
|
|
@ -424,7 +469,7 @@ def build_legacygl_header(filename, include, class_suffix, output_attribs, gles2
|
|||
if header_data.texunits:
|
||||
fd.write("\t\tstatic TexUnitPair _texunit_pairs[]={\n")
|
||||
for x in header_data.texunits:
|
||||
fd.write("\t\t\t{\"" + x[0] + "\"," + x[1] + "},\n")
|
||||
fd.write('\t\t\t{"' + x[0] + '",' + x[1] + "},\n")
|
||||
fd.write("\t\t};\n\n")
|
||||
else:
|
||||
fd.write("\t\tstatic TexUnitPair *_texunit_pairs=NULL;\n")
|
||||
|
|
@ -432,7 +477,7 @@ def build_legacygl_header(filename, include, class_suffix, output_attribs, gles2
|
|||
if not gles2 and header_data.ubos:
|
||||
fd.write("\t\tstatic UBOPair _ubo_pairs[]={\n")
|
||||
for x in header_data.ubos:
|
||||
fd.write("\t\t\t{\"" + x[0] + "\"," + x[1] + "},\n")
|
||||
fd.write('\t\t\t{"' + x[0] + '",' + x[1] + "},\n")
|
||||
fd.write("\t\t};\n\n")
|
||||
else:
|
||||
if gles2:
|
||||
|
|
@ -445,7 +490,7 @@ def build_legacygl_header(filename, include, class_suffix, output_attribs, gles2
|
|||
for c in x:
|
||||
fd.write(str(ord(c)) + ",")
|
||||
|
||||
fd.write(str(ord('\n')) + ",")
|
||||
fd.write(str(ord("\n")) + ",")
|
||||
fd.write("\t\t0};\n\n")
|
||||
|
||||
fd.write("\t\tstatic const int _vertex_code_start=" + str(header_data.vertex_offset) + ";\n")
|
||||
|
|
@ -455,28 +500,73 @@ def build_legacygl_header(filename, include, class_suffix, output_attribs, gles2
|
|||
for c in x:
|
||||
fd.write(str(ord(c)) + ",")
|
||||
|
||||
fd.write(str(ord('\n')) + ",")
|
||||
fd.write(str(ord("\n")) + ",")
|
||||
fd.write("\t\t0};\n\n")
|
||||
|
||||
fd.write("\t\tstatic const int _fragment_code_start=" + str(header_data.fragment_offset) + ";\n")
|
||||
|
||||
if output_attribs:
|
||||
if gles2:
|
||||
fd.write("\t\tsetup(_conditional_strings," + str(len(header_data.conditionals)) + ",_uniform_strings," + str(len(header_data.uniforms)) + ",_attribute_pairs," + str(
|
||||
len(header_data.attributes)) + ", _texunit_pairs," + str(len(header_data.texunits)) + ",_vertex_code,_fragment_code,_vertex_code_start,_fragment_code_start);\n")
|
||||
fd.write(
|
||||
"\t\tsetup(_conditional_strings,"
|
||||
+ str(len(header_data.conditionals))
|
||||
+ ",_uniform_strings,"
|
||||
+ str(len(header_data.uniforms))
|
||||
+ ",_attribute_pairs,"
|
||||
+ str(len(header_data.attributes))
|
||||
+ ", _texunit_pairs,"
|
||||
+ str(len(header_data.texunits))
|
||||
+ ",_vertex_code,_fragment_code,_vertex_code_start,_fragment_code_start);\n"
|
||||
)
|
||||
else:
|
||||
fd.write("\t\tsetup(_conditional_strings," + str(len(header_data.conditionals)) + ",_uniform_strings," + str(len(header_data.uniforms)) + ",_attribute_pairs," + str(
|
||||
len(header_data.attributes)) + ", _texunit_pairs," + str(len(header_data.texunits)) + ",_ubo_pairs," + str(len(header_data.ubos)) + ",_feedbacks," + str(
|
||||
feedback_count) + ",_vertex_code,_fragment_code,_vertex_code_start,_fragment_code_start);\n")
|
||||
fd.write(
|
||||
"\t\tsetup(_conditional_strings,"
|
||||
+ str(len(header_data.conditionals))
|
||||
+ ",_uniform_strings,"
|
||||
+ str(len(header_data.uniforms))
|
||||
+ ",_attribute_pairs,"
|
||||
+ str(len(header_data.attributes))
|
||||
+ ", _texunit_pairs,"
|
||||
+ str(len(header_data.texunits))
|
||||
+ ",_ubo_pairs,"
|
||||
+ str(len(header_data.ubos))
|
||||
+ ",_feedbacks,"
|
||||
+ str(feedback_count)
|
||||
+ ",_vertex_code,_fragment_code,_vertex_code_start,_fragment_code_start);\n"
|
||||
)
|
||||
else:
|
||||
if gles2:
|
||||
fd.write("\t\tsetup(_conditional_strings," + str(len(header_data.conditionals)) + ",_uniform_strings," + str(len(header_data.uniforms)) + ",_texunit_pairs," + str(
|
||||
len(header_data.texunits)) + ",_enums," + str(len(header_data.enums)) + ",_enum_values," + str(
|
||||
enum_value_count) + ",_vertex_code,_fragment_code,_vertex_code_start,_fragment_code_start);\n")
|
||||
fd.write(
|
||||
"\t\tsetup(_conditional_strings,"
|
||||
+ str(len(header_data.conditionals))
|
||||
+ ",_uniform_strings,"
|
||||
+ str(len(header_data.uniforms))
|
||||
+ ",_texunit_pairs,"
|
||||
+ str(len(header_data.texunits))
|
||||
+ ",_enums,"
|
||||
+ str(len(header_data.enums))
|
||||
+ ",_enum_values,"
|
||||
+ str(enum_value_count)
|
||||
+ ",_vertex_code,_fragment_code,_vertex_code_start,_fragment_code_start);\n"
|
||||
)
|
||||
else:
|
||||
fd.write("\t\tsetup(_conditional_strings," + str(len(header_data.conditionals)) + ",_uniform_strings," + str(len(header_data.uniforms)) + ",_texunit_pairs," + str(
|
||||
len(header_data.texunits)) + ",_enums," + str(len(header_data.enums)) + ",_enum_values," + str(enum_value_count) + ",_ubo_pairs," + str(len(header_data.ubos)) + ",_feedbacks," + str(
|
||||
feedback_count) + ",_vertex_code,_fragment_code,_vertex_code_start,_fragment_code_start);\n")
|
||||
fd.write(
|
||||
"\t\tsetup(_conditional_strings,"
|
||||
+ str(len(header_data.conditionals))
|
||||
+ ",_uniform_strings,"
|
||||
+ str(len(header_data.uniforms))
|
||||
+ ",_texunit_pairs,"
|
||||
+ str(len(header_data.texunits))
|
||||
+ ",_enums,"
|
||||
+ str(len(header_data.enums))
|
||||
+ ",_enum_values,"
|
||||
+ str(enum_value_count)
|
||||
+ ",_ubo_pairs,"
|
||||
+ str(len(header_data.ubos))
|
||||
+ ",_feedbacks,"
|
||||
+ str(feedback_count)
|
||||
+ ",_vertex_code,_fragment_code,_vertex_code_start,_fragment_code_start);\n"
|
||||
)
|
||||
|
||||
fd.write("\t}\n\n")
|
||||
|
||||
|
|
@ -495,12 +585,12 @@ def build_legacygl_header(filename, include, class_suffix, output_attribs, gles2
|
|||
|
||||
def build_gles2_headers(target, source, env):
|
||||
for x in source:
|
||||
build_legacygl_header(str(x), include="drivers/gles2/shader_gles2.h", class_suffix="GLES2", output_attribs=True, gles2=True)
|
||||
|
||||
build_legacygl_header(
|
||||
str(x), include="drivers/gles2/shader_gles2.h", class_suffix="GLES2", output_attribs=True, gles2=True
|
||||
)
|
||||
|
||||
|
||||
class RDHeaderStruct:
|
||||
|
||||
def __init__(self):
|
||||
self.vertex_lines = []
|
||||
self.fragment_lines = []
|
||||
|
|
@ -602,22 +692,22 @@ def build_rd_header(filename):
|
|||
|
||||
out_file_class = out_file_base.replace(".glsl.gen.h", "").title().replace("_", "").replace(".", "") + "ShaderRD"
|
||||
fd.write("\n")
|
||||
fd.write("#include \"servers/rendering/rasterizer_rd/shader_rd.h\"\n\n")
|
||||
fd.write('#include "servers/rendering/rasterizer_rd/shader_rd.h"\n\n')
|
||||
fd.write("class " + out_file_class + " : public ShaderRD {\n\n")
|
||||
fd.write("public:\n\n")
|
||||
|
||||
fd.write("\t" + out_file_class + "() {\n\n")
|
||||
|
||||
if (len(header_data.compute_lines)):
|
||||
if len(header_data.compute_lines):
|
||||
|
||||
fd.write("\t\tstatic const char _compute_code[] = {\n")
|
||||
for x in header_data.compute_lines:
|
||||
for c in x:
|
||||
fd.write(str(ord(c)) + ",")
|
||||
fd.write(str(ord('\n')) + ",")
|
||||
fd.write(str(ord("\n")) + ",")
|
||||
fd.write("\t\t0};\n\n")
|
||||
|
||||
fd.write("\t\tsetup(nullptr, nullptr, _compute_code, \"" + out_file_class + "\");\n")
|
||||
fd.write('\t\tsetup(nullptr, nullptr, _compute_code, "' + out_file_class + '");\n')
|
||||
fd.write("\t}\n")
|
||||
|
||||
else:
|
||||
|
|
@ -626,17 +716,17 @@ def build_rd_header(filename):
|
|||
for x in header_data.vertex_lines:
|
||||
for c in x:
|
||||
fd.write(str(ord(c)) + ",")
|
||||
fd.write(str(ord('\n')) + ",")
|
||||
fd.write(str(ord("\n")) + ",")
|
||||
fd.write("\t\t0};\n\n")
|
||||
|
||||
fd.write("\t\tstatic const char _fragment_code[]={\n")
|
||||
for x in header_data.fragment_lines:
|
||||
for c in x:
|
||||
fd.write(str(ord(c)) + ",")
|
||||
fd.write(str(ord('\n')) + ",")
|
||||
fd.write(str(ord("\n")) + ",")
|
||||
fd.write("\t\t0};\n\n")
|
||||
|
||||
fd.write("\t\tsetup(_vertex_code, _fragment_code, nullptr, \"" + out_file_class + "\");\n")
|
||||
fd.write('\t\tsetup(_vertex_code, _fragment_code, nullptr, "' + out_file_class + '");\n')
|
||||
fd.write("\t}\n")
|
||||
|
||||
fd.write("};\n\n")
|
||||
|
|
@ -650,5 +740,5 @@ def build_rd_headers(target, source, env):
|
|||
build_rd_header(str(x))
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
if __name__ == "__main__":
|
||||
subprocess_main(globals())
|
||||
|
|
|
|||
|
|
@ -1,6 +1,6 @@
|
|||
#!/usr/bin/env python
|
||||
|
||||
Import('env')
|
||||
Import("env")
|
||||
|
||||
from platform_methods import run_in_subprocess
|
||||
import main_builders
|
||||
|
|
@ -14,13 +14,15 @@ env.Depends("#main/splash.gen.h", "#main/splash.png")
|
|||
env.CommandNoCache("#main/splash.gen.h", "#main/splash.png", run_in_subprocess(main_builders.make_splash))
|
||||
|
||||
env.Depends("#main/splash_editor.gen.h", "#main/splash_editor.png")
|
||||
env.CommandNoCache("#main/splash_editor.gen.h", "#main/splash_editor.png", run_in_subprocess(main_builders.make_splash_editor))
|
||||
env.CommandNoCache(
|
||||
"#main/splash_editor.gen.h", "#main/splash_editor.png", run_in_subprocess(main_builders.make_splash_editor)
|
||||
)
|
||||
|
||||
env.Depends("#main/app_icon.gen.h", "#main/app_icon.png")
|
||||
env.CommandNoCache("#main/app_icon.gen.h", "#main/app_icon.png", run_in_subprocess(main_builders.make_app_icon))
|
||||
|
||||
if env["tools"]:
|
||||
SConscript('tests/SCsub')
|
||||
SConscript("tests/SCsub")
|
||||
|
||||
lib = env.add_library("main", env.main_sources)
|
||||
env.Prepend(LIBS=[lib])
|
||||
|
|
|
|||
|
|
@ -18,7 +18,7 @@ def make_splash(target, source, env):
|
|||
g.write("/* THIS FILE IS GENERATED DO NOT EDIT */\n")
|
||||
g.write("#ifndef BOOT_SPLASH_H\n")
|
||||
g.write("#define BOOT_SPLASH_H\n")
|
||||
g.write('static const Color boot_splash_bg_color = Color(0.14, 0.14, 0.14);\n')
|
||||
g.write("static const Color boot_splash_bg_color = Color(0.14, 0.14, 0.14);\n")
|
||||
g.write("static const unsigned char boot_splash_png[] = {\n")
|
||||
for i in range(len(buf)):
|
||||
g.write(str(buf[i]) + ",\n")
|
||||
|
|
@ -37,7 +37,7 @@ def make_splash_editor(target, source, env):
|
|||
g.write("/* THIS FILE IS GENERATED DO NOT EDIT */\n")
|
||||
g.write("#ifndef BOOT_SPLASH_EDITOR_H\n")
|
||||
g.write("#define BOOT_SPLASH_EDITOR_H\n")
|
||||
g.write('static const Color boot_splash_editor_bg_color = Color(0.14, 0.14, 0.14);\n')
|
||||
g.write("static const Color boot_splash_editor_bg_color = Color(0.14, 0.14, 0.14);\n")
|
||||
g.write("static const unsigned char boot_splash_editor_png[] = {\n")
|
||||
for i in range(len(buf)):
|
||||
g.write(str(buf[i]) + ",\n")
|
||||
|
|
@ -63,5 +63,5 @@ def make_app_icon(target, source, env):
|
|||
g.write("#endif")
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
if __name__ == "__main__":
|
||||
subprocess_main(globals())
|
||||
|
|
|
|||
|
|
@ -1,6 +1,6 @@
|
|||
#!/usr/bin/python
|
||||
|
||||
Import('env')
|
||||
Import("env")
|
||||
|
||||
env.tests_sources = []
|
||||
env.add_source_files(env.tests_sources, "*.cpp")
|
||||
|
|
|
|||
311
methods.py
311
methods.py
|
|
@ -8,13 +8,13 @@ def add_source_files(self, sources, files, warn_duplicates=True):
|
|||
# Convert string to list of absolute paths (including expanding wildcard)
|
||||
if isinstance(files, (str, bytes)):
|
||||
# Keep SCons project-absolute path as they are (no wildcard support)
|
||||
if files.startswith('#'):
|
||||
if '*' in files:
|
||||
if files.startswith("#"):
|
||||
if "*" in files:
|
||||
print("ERROR: Wildcards can't be expanded in SCons project-absolute path: '{}'".format(files))
|
||||
return
|
||||
files = [files]
|
||||
else:
|
||||
dir_path = self.Dir('.').abspath
|
||||
dir_path = self.Dir(".").abspath
|
||||
files = sorted(glob.glob(dir_path + "/" + files))
|
||||
|
||||
# Add each path as compiled Object following environment (self) configuration
|
||||
|
|
@ -22,7 +22,7 @@ def add_source_files(self, sources, files, warn_duplicates=True):
|
|||
obj = self.Object(path)
|
||||
if obj in sources:
|
||||
if warn_duplicates:
|
||||
print("WARNING: Object \"{}\" already included in environment sources.".format(obj))
|
||||
print('WARNING: Object "{}" already included in environment sources.'.format(obj))
|
||||
else:
|
||||
continue
|
||||
sources.append(obj)
|
||||
|
|
@ -33,17 +33,17 @@ def disable_warnings(self):
|
|||
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(CXXFLAGS=['/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]
|
||||
warn_flags = ["/Wall", "/W4", "/W3", "/W2", "/W1", "/WX"]
|
||||
self.Append(CCFLAGS=["/w"])
|
||||
self.Append(CFLAGS=["/w"])
|
||||
self.Append(CXXFLAGS=["/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'])
|
||||
self.Append(CCFLAGS=["-w"])
|
||||
self.Append(CFLAGS=["-w"])
|
||||
self.Append(CXXFLAGS=["-w"])
|
||||
|
||||
|
||||
def add_module_version_string(self, s):
|
||||
|
|
@ -64,16 +64,16 @@ def update_version(module_version_string=""):
|
|||
f.write("/* THIS FILE IS GENERATED DO NOT EDIT */\n")
|
||||
f.write("#ifndef VERSION_GENERATED_GEN_H\n")
|
||||
f.write("#define VERSION_GENERATED_GEN_H\n")
|
||||
f.write("#define VERSION_SHORT_NAME \"" + str(version.short_name) + "\"\n")
|
||||
f.write("#define VERSION_NAME \"" + str(version.name) + "\"\n")
|
||||
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")
|
||||
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_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.write("#define VERSION_WEBSITE \"" + str(version.website) + "\"\n")
|
||||
f.write('#define VERSION_WEBSITE "' + str(version.website) + '"\n')
|
||||
f.write("#endif // VERSION_GENERATED_GEN_H\n")
|
||||
f.close()
|
||||
|
||||
|
|
@ -99,7 +99,7 @@ def update_version(module_version_string=""):
|
|||
else:
|
||||
githash = head
|
||||
|
||||
fhash.write("#define VERSION_HASH \"" + githash + "\"\n")
|
||||
fhash.write('#define VERSION_HASH "' + githash + '"\n')
|
||||
fhash.write("#endif // VERSION_HASH_GEN_H\n")
|
||||
fhash.close()
|
||||
|
||||
|
|
@ -158,17 +158,17 @@ def detect_modules():
|
|||
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'
|
||||
preregister_cpp += '#ifdef MODULE_' + x.upper() + '_ENABLED\n'
|
||||
preregister_cpp += '#ifdef MODULE_' + x.upper() + '_HAS_PREREGISTER\n'
|
||||
preregister_cpp += '\tpreregister_' + x + '_types();\n'
|
||||
preregister_cpp += '#endif\n'
|
||||
preregister_cpp += '#endif\n'
|
||||
unregister_cpp += '#ifdef MODULE_' + x.upper() + '_ENABLED\n'
|
||||
unregister_cpp += '\tunregister_' + x + '_types();\n'
|
||||
unregister_cpp += '#endif\n'
|
||||
register_cpp += "#ifdef MODULE_" + x.upper() + "_ENABLED\n"
|
||||
register_cpp += "\tregister_" + x + "_types();\n"
|
||||
register_cpp += "#endif\n"
|
||||
preregister_cpp += "#ifdef MODULE_" + x.upper() + "_ENABLED\n"
|
||||
preregister_cpp += "#ifdef MODULE_" + x.upper() + "_HAS_PREREGISTER\n"
|
||||
preregister_cpp += "\tpreregister_" + x + "_types();\n"
|
||||
preregister_cpp += "#endif\n"
|
||||
preregister_cpp += "#endif\n"
|
||||
unregister_cpp += "#ifdef MODULE_" + x.upper() + "_ENABLED\n"
|
||||
unregister_cpp += "\tunregister_" + x + "_types();\n"
|
||||
unregister_cpp += "#endif\n"
|
||||
except IOError:
|
||||
pass
|
||||
|
||||
|
|
@ -191,7 +191,12 @@ void register_module_types() {
|
|||
void unregister_module_types() {
|
||||
%s
|
||||
}
|
||||
""" % (includes_cpp, preregister_cpp, register_cpp, unregister_cpp)
|
||||
""" % (
|
||||
includes_cpp,
|
||||
preregister_cpp,
|
||||
register_cpp,
|
||||
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:
|
||||
|
|
@ -206,7 +211,7 @@ def disable_module(self):
|
|||
|
||||
def use_windows_spawn_fix(self, platform=None):
|
||||
|
||||
if (os.name != "nt"):
|
||||
if os.name != "nt":
|
||||
return # not needed, only for windows
|
||||
|
||||
# On Windows, due to the limited command line length, when creating a static library
|
||||
|
|
@ -217,14 +222,21 @@ def use_windows_spawn_fix(self, platform=None):
|
|||
# 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')
|
||||
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)
|
||||
proc = subprocess.Popen(
|
||||
cmdline,
|
||||
stdin=subprocess.PIPE,
|
||||
stdout=subprocess.PIPE,
|
||||
stderr=subprocess.PIPE,
|
||||
startupinfo=startupinfo,
|
||||
shell=False,
|
||||
env=env,
|
||||
)
|
||||
_, err = proc.communicate()
|
||||
rv = proc.wait()
|
||||
if rv:
|
||||
|
|
@ -235,7 +247,7 @@ def use_windows_spawn_fix(self, platform=None):
|
|||
|
||||
def mySpawn(sh, escape, cmd, args, env):
|
||||
|
||||
newargs = ' '.join(args[1:])
|
||||
newargs = " ".join(args[1:])
|
||||
cmdline = cmd + " " + newargs
|
||||
|
||||
rv = 0
|
||||
|
|
@ -251,15 +263,15 @@ def use_windows_spawn_fix(self, platform=None):
|
|||
|
||||
return rv
|
||||
|
||||
self['SPAWN'] = mySpawn
|
||||
self["SPAWN"] = mySpawn
|
||||
|
||||
|
||||
def save_active_platforms(apnames, ap):
|
||||
|
||||
for x in ap:
|
||||
names = ['logo']
|
||||
names = ["logo"]
|
||||
if os.path.isfile(x + "/run_icon.png"):
|
||||
names.append('run_icon')
|
||||
names.append("run_icon")
|
||||
|
||||
for name in names:
|
||||
pngf = open(x + "/" + name + ".png", "rb")
|
||||
|
|
@ -269,7 +281,7 @@ def save_active_platforms(apnames, ap):
|
|||
while len(b) == 1:
|
||||
str += hex(ord(b))
|
||||
b = pngf.read(1)
|
||||
if (len(b) == 1):
|
||||
if len(b) == 1:
|
||||
str += ","
|
||||
|
||||
str += "};\n"
|
||||
|
|
@ -289,30 +301,46 @@ def no_verbose(sys, env):
|
|||
# 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'
|
||||
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'] = ''
|
||||
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'])
|
||||
compile_source_message = "{}Compiling {}==> {}$SOURCE{}".format(
|
||||
colors["blue"], colors["purple"], colors["yellow"], colors["end"]
|
||||
)
|
||||
java_compile_source_message = "{}Compiling {}==> {}$SOURCE{}".format(
|
||||
colors["blue"], colors["purple"], colors["yellow"], colors["end"]
|
||||
)
|
||||
compile_shared_source_message = "{}Compiling shared {}==> {}$SOURCE{}".format(
|
||||
colors["blue"], colors["purple"], colors["yellow"], colors["end"]
|
||||
)
|
||||
link_program_message = "{}Linking Program {}==> {}$TARGET{}".format(
|
||||
colors["red"], colors["purple"], colors["yellow"], colors["end"]
|
||||
)
|
||||
link_library_message = "{}Linking Static Library {}==> {}$TARGET{}".format(
|
||||
colors["red"], colors["purple"], colors["yellow"], colors["end"]
|
||||
)
|
||||
ranlib_library_message = "{}Ranlib Library {}==> {}$TARGET{}".format(
|
||||
colors["red"], colors["purple"], colors["yellow"], colors["end"]
|
||||
)
|
||||
link_shared_library_message = "{}Linking Shared Library {}==> {}$TARGET{}".format(
|
||||
colors["red"], colors["purple"], colors["yellow"], colors["end"]
|
||||
)
|
||||
java_library_message = "{}Creating Java Archive {}==> {}$TARGET{}".format(
|
||||
colors["red"], colors["purple"], colors["yellow"], colors["end"]
|
||||
)
|
||||
|
||||
env.Append(CXXCOMSTR=[compile_source_message])
|
||||
env.Append(CCCOMSTR=[compile_source_message])
|
||||
|
|
@ -353,70 +381,79 @@ def detect_visual_c_compiler_version(tools_env):
|
|||
vc_chosen_compiler_str = ""
|
||||
|
||||
# Start with Pre VS 2017 checks which uses VCINSTALLDIR:
|
||||
if 'VCINSTALLDIR' in tools_env:
|
||||
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):
|
||||
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)):
|
||||
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)):
|
||||
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_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:
|
||||
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_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_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_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_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
|
||||
|
||||
|
|
@ -424,6 +461,7 @@ def find_visual_c_batch_file(env):
|
|||
(host_platform, 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.
|
||||
|
|
@ -435,15 +473,19 @@ def generate_cpp_hint_file(filename):
|
|||
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)"',
|
||||
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!']
|
||||
'call "' + batch_file + '" !plat!',
|
||||
]
|
||||
|
||||
result = " ^& ".join(common_build_prefix + [commands])
|
||||
return result
|
||||
|
|
@ -459,87 +501,104 @@ def generate_vs_project(env, num_jobs):
|
|||
# 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))
|
||||
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']
|
||||
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']
|
||||
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'
|
||||
if not env.get("MSVS"):
|
||||
env["MSVS"]["PROJECTSUFFIX"] = ".vcxproj"
|
||||
env["MSVS"]["SOLUTIONSUFFIX"] = ".sln"
|
||||
env.MSVSProject(
|
||||
target=['#godot' + env['MSVSPROJECTSUFFIX']],
|
||||
target=["#godot" + env["MSVSPROJECTSUFFIX"]],
|
||||
incs=env.vs_incs,
|
||||
srcs=env.vs_srcs,
|
||||
runfile=targets,
|
||||
buildtarget=targets,
|
||||
auto_build_solution=1,
|
||||
variant=variants)
|
||||
variant=variants,
|
||||
)
|
||||
else:
|
||||
print("Could not locate Visual Studio batch file for setting up the build environment. Not generating VS project.")
|
||||
print("Could not locate Visual Studio batch file to set 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'
|
||||
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 = subprocess.check_output(['xcrun', '--sdk', sdk_name, '--show-sdk-path']).strip().decode("utf-8")
|
||||
sdk_path = subprocess.check_output(["xcrun", "--sdk", sdk_name, "--show-sdk-path"]).strip().decode("utf-8")
|
||||
if sdk_path:
|
||||
env[var_name] = sdk_path
|
||||
except (subprocess.CalledProcessError, OSError):
|
||||
print("Failed to find SDK path while running xcrun --sdk {} --show-sdk-path.".format(sdk_name))
|
||||
raise
|
||||
|
||||
|
||||
def is_vanilla_clang(env):
|
||||
if not using_clang(env):
|
||||
return False
|
||||
version = subprocess.check_output([env['CXX'], '--version']).strip().decode("utf-8")
|
||||
version = subprocess.check_output([env["CXX"], "--version"]).strip().decode("utf-8")
|
||||
return not version.startswith("Apple")
|
||||
|
||||
|
||||
|
|
@ -552,20 +611,22 @@ def get_compiler_version(env):
|
|||
# Not using -dumpversion as some GCC distros only return major, and
|
||||
# Clang used to return hardcoded 4.2.1: # https://reviews.llvm.org/D56803
|
||||
try:
|
||||
version = subprocess.check_output([env.subst(env['CXX']), '--version']).strip().decode("utf-8")
|
||||
version = subprocess.check_output([env.subst(env["CXX"]), "--version"]).strip().decode("utf-8")
|
||||
except (subprocess.CalledProcessError, OSError):
|
||||
print("Couldn't parse CXX environment variable to infer compiler version.")
|
||||
return None
|
||||
else: # TODO: Implement for MSVC
|
||||
return None
|
||||
match = re.search('[0-9]+\.[0-9.]+', version)
|
||||
match = re.search("[0-9]+\.[0-9.]+", version)
|
||||
if match is not None:
|
||||
return list(map(int, match.group().split('.')))
|
||||
return list(map(int, match.group().split(".")))
|
||||
else:
|
||||
return None
|
||||
|
||||
|
||||
def using_gcc(env):
|
||||
return 'gcc' in os.path.basename(env["CC"])
|
||||
return "gcc" in os.path.basename(env["CC"])
|
||||
|
||||
|
||||
def using_clang(env):
|
||||
return 'clang' in os.path.basename(env["CC"])
|
||||
return "clang" in os.path.basename(env["CC"])
|
||||
|
|
|
|||
|
|
@ -37,24 +37,24 @@ files = open("files", "r")
|
|||
|
||||
fname = files.readline()
|
||||
|
||||
while (fname != ""):
|
||||
while fname != "":
|
||||
|
||||
# Handle replacing $filename with actual filename and keep alignment
|
||||
fsingle = fname.strip()
|
||||
if (fsingle.find("/") != -1):
|
||||
if fsingle.find("/") != -1:
|
||||
fsingle = fsingle[fsingle.rfind("/") + 1 :]
|
||||
rep_fl = "$filename"
|
||||
rep_fi = fsingle
|
||||
len_fl = len(rep_fl)
|
||||
len_fi = len(rep_fi)
|
||||
# Pad with spaces to keep alignment
|
||||
if (len_fi < len_fl):
|
||||
if len_fi < len_fl:
|
||||
for x in range(len_fl - len_fi):
|
||||
rep_fi += " "
|
||||
elif (len_fl < len_fi):
|
||||
elif len_fl < len_fi:
|
||||
for x in range(len_fi - len_fl):
|
||||
rep_fl += " "
|
||||
if (header.find(rep_fl) != -1):
|
||||
if header.find(rep_fl) != -1:
|
||||
text = header.replace(rep_fl, rep_fi)
|
||||
else:
|
||||
text = header.replace("$filename", fsingle)
|
||||
|
|
@ -71,21 +71,21 @@ while (fname != ""):
|
|||
line = fileread.readline()
|
||||
header_done = False
|
||||
|
||||
while (line.strip() == ""): # Skip empty lines at the top
|
||||
while line.strip() == "": # Skip empty lines at the top
|
||||
line = fileread.readline()
|
||||
|
||||
if (line.find("/**********") == -1): # Godot header starts this way
|
||||
if line.find("/**********") == -1: # Godot header starts this way
|
||||
# Maybe starting with a non-Godot comment, abort header magic
|
||||
header_done = True
|
||||
|
||||
while (not header_done): # Handle header now
|
||||
if (line.find("/*") != 0): # No more starting with a comment
|
||||
while not header_done: # Handle header now
|
||||
if line.find("/*") != 0: # No more starting with a comment
|
||||
header_done = True
|
||||
if (line.strip() != ""):
|
||||
if line.strip() != "":
|
||||
text += line
|
||||
line = fileread.readline()
|
||||
|
||||
while (line != ""): # Dump everything until EOF
|
||||
while line != "": # Dump everything until EOF
|
||||
text += line
|
||||
line = fileread.readline()
|
||||
|
||||
|
|
|
|||
|
|
@ -1,12 +1,12 @@
|
|||
#!/usr/bin/env python
|
||||
|
||||
Import('env')
|
||||
Import("env")
|
||||
|
||||
import modules_builders
|
||||
|
||||
env_modules = env.Clone()
|
||||
|
||||
Export('env_modules')
|
||||
Export("env_modules")
|
||||
|
||||
# Header with MODULE_*_ENABLED defines.
|
||||
env.CommandNoCache("modules_enabled.gen.h", Value(env.module_list), modules_builders.generate_modules_enabled)
|
||||
|
|
|
|||
|
|
@ -1,7 +1,7 @@
|
|||
#!/usr/bin/env python
|
||||
|
||||
Import('env')
|
||||
Import('env_modules')
|
||||
Import("env")
|
||||
Import("env_modules")
|
||||
|
||||
env_arkit = env_modules.Clone()
|
||||
|
||||
|
|
@ -9,4 +9,4 @@ env_arkit = env_modules.Clone()
|
|||
modules_sources = []
|
||||
env_arkit.add_source_files(modules_sources, "*.cpp")
|
||||
env_arkit.add_source_files(modules_sources, "*.mm")
|
||||
mod_lib = env_modules.add_library('#bin/libgodot_arkit_module' + env['LIBSUFFIX'], modules_sources)
|
||||
mod_lib = env_modules.add_library("#bin/libgodot_arkit_module" + env["LIBSUFFIX"], modules_sources)
|
||||
|
|
|
|||
|
|
@ -1,5 +1,6 @@
|
|||
def can_build(env, platform):
|
||||
return platform == 'iphone'
|
||||
return platform == "iphone"
|
||||
|
||||
|
||||
def configure(env):
|
||||
pass
|
||||
|
|
|
|||
|
|
@ -1,7 +1,7 @@
|
|||
#!/usr/bin/env python
|
||||
|
||||
Import('env')
|
||||
Import('env_modules')
|
||||
Import("env")
|
||||
Import("env_modules")
|
||||
|
||||
env_assimp = env_modules.Clone()
|
||||
|
||||
|
|
@ -10,85 +10,85 @@ env_assimp = env_modules.Clone()
|
|||
if True: # env['builtin_assimp']:
|
||||
thirdparty_dir = "#thirdparty/assimp"
|
||||
|
||||
env_assimp.Prepend(CPPPATH=['#thirdparty/assimp'])
|
||||
env_assimp.Prepend(CPPPATH=['#thirdparty/assimp/code'])
|
||||
env_assimp.Prepend(CPPPATH=['#thirdparty/assimp/include'])
|
||||
env_assimp.Prepend(CPPPATH=["#thirdparty/assimp"])
|
||||
env_assimp.Prepend(CPPPATH=["#thirdparty/assimp/code"])
|
||||
env_assimp.Prepend(CPPPATH=["#thirdparty/assimp/include"])
|
||||
|
||||
# env_assimp.Append(CPPDEFINES=['ASSIMP_DOUBLE_PRECISION']) # TODO default to what godot is compiled with for future double support
|
||||
env_assimp.Append(CPPDEFINES=['ASSIMP_BUILD_SINGLETHREADED'])
|
||||
env_assimp.Append(CPPDEFINES=['ASSIMP_BUILD_BOOST_WORKAROUND'])
|
||||
env_assimp.Append(CPPDEFINES=['ASSIMP_BUILD_NO_OWN_ZLIB'])
|
||||
env_assimp.Append(CPPDEFINES=['ASSIMP_BUILD_NO_EXPORT'])
|
||||
env_assimp.Append(CPPDEFINES=["ASSIMP_BUILD_SINGLETHREADED"])
|
||||
env_assimp.Append(CPPDEFINES=["ASSIMP_BUILD_BOOST_WORKAROUND"])
|
||||
env_assimp.Append(CPPDEFINES=["ASSIMP_BUILD_NO_OWN_ZLIB"])
|
||||
env_assimp.Append(CPPDEFINES=["ASSIMP_BUILD_NO_EXPORT"])
|
||||
|
||||
# Importers we don't need
|
||||
env_assimp.Append(CPPDEFINES=['ASSIMP_BUILD_NO_3D_IMPORTER'])
|
||||
env_assimp.Append(CPPDEFINES=['ASSIMP_BUILD_NO_3DS_IMPORTER'])
|
||||
env_assimp.Append(CPPDEFINES=['ASSIMP_BUILD_NO_3MF_IMPORTER'])
|
||||
env_assimp.Append(CPPDEFINES=['ASSIMP_BUILD_NO_AC_IMPORTER'])
|
||||
env_assimp.Append(CPPDEFINES=['ASSIMP_BUILD_NO_AMF_IMPORTER'])
|
||||
env_assimp.Append(CPPDEFINES=['ASSIMP_BUILD_NO_ASE_IMPORTER'])
|
||||
env_assimp.Append(CPPDEFINES=['ASSIMP_BUILD_NO_ASSBIN_IMPORTER'])
|
||||
env_assimp.Append(CPPDEFINES=['ASSIMP_BUILD_NO_B3D_IMPORTER'])
|
||||
env_assimp.Append(CPPDEFINES=['ASSIMP_BUILD_NO_BLEND_IMPORTER'])
|
||||
env_assimp.Append(CPPDEFINES=['ASSIMP_BUILD_NO_BVH_IMPORTER'])
|
||||
env_assimp.Append(CPPDEFINES=['ASSIMP_BUILD_NO_C4D_IMPORTER'])
|
||||
env_assimp.Append(CPPDEFINES=['ASSIMP_BUILD_NO_COB_IMPORTER'])
|
||||
env_assimp.Append(CPPDEFINES=['ASSIMP_BUILD_NO_COLLADA_IMPORTER'])
|
||||
env_assimp.Append(CPPDEFINES=['ASSIMP_BUILD_NO_CSM_IMPORTER'])
|
||||
env_assimp.Append(CPPDEFINES=['ASSIMP_BUILD_NO_DXF_IMPORTER'])
|
||||
env_assimp.Append(CPPDEFINES=['ASSIMP_BUILD_NO_GLTF2_IMPORTER'])
|
||||
env_assimp.Append(CPPDEFINES=['ASSIMP_BUILD_NO_GLTF_IMPORTER'])
|
||||
env_assimp.Append(CPPDEFINES=['ASSIMP_BUILD_NO_HMP_IMPORTER'])
|
||||
env_assimp.Append(CPPDEFINES=['ASSIMP_BUILD_NO_IFC_IMPORTER'])
|
||||
env_assimp.Append(CPPDEFINES=['ASSIMP_BUILD_NO_IRR_IMPORTER'])
|
||||
env_assimp.Append(CPPDEFINES=['ASSIMP_BUILD_NO_IRRMESH_IMPORTER'])
|
||||
env_assimp.Append(CPPDEFINES=['ASSIMP_BUILD_NO_LWO_IMPORTER'])
|
||||
env_assimp.Append(CPPDEFINES=['ASSIMP_BUILD_NO_LWS_IMPORTER'])
|
||||
env_assimp.Append(CPPDEFINES=['ASSIMP_BUILD_NO_M3D_IMPORTER'])
|
||||
env_assimp.Append(CPPDEFINES=['ASSIMP_BUILD_NO_MD2_IMPORTER'])
|
||||
env_assimp.Append(CPPDEFINES=['ASSIMP_BUILD_NO_MD3_IMPORTER'])
|
||||
env_assimp.Append(CPPDEFINES=['ASSIMP_BUILD_NO_MD5_IMPORTER'])
|
||||
env_assimp.Append(CPPDEFINES=['ASSIMP_BUILD_NO_MD5_IMPORTER'])
|
||||
env_assimp.Append(CPPDEFINES=['ASSIMP_BUILD_NO_MDC_IMPORTER'])
|
||||
env_assimp.Append(CPPDEFINES=['ASSIMP_BUILD_NO_MDL_IMPORTER'])
|
||||
env_assimp.Append(CPPDEFINES=['ASSIMP_BUILD_NO_MMD_IMPORTER'])
|
||||
env_assimp.Append(CPPDEFINES=['ASSIMP_BUILD_NO_MS3D_IMPORTER'])
|
||||
env_assimp.Append(CPPDEFINES=['ASSIMP_BUILD_NO_NDO_IMPORTER'])
|
||||
env_assimp.Append(CPPDEFINES=['ASSIMP_BUILD_NO_NFF_IMPORTER'])
|
||||
env_assimp.Append(CPPDEFINES=['ASSIMP_BUILD_NO_OBJ_IMPORTER'])
|
||||
env_assimp.Append(CPPDEFINES=['ASSIMP_BUILD_NO_OFF_IMPORTER'])
|
||||
env_assimp.Append(CPPDEFINES=['ASSIMP_BUILD_NO_OGRE_IMPORTER'])
|
||||
env_assimp.Append(CPPDEFINES=['ASSIMP_BUILD_NO_OPENGEX_IMPORTER'])
|
||||
env_assimp.Append(CPPDEFINES=['ASSIMP_BUILD_NO_PLY_IMPORTER'])
|
||||
env_assimp.Append(CPPDEFINES=['ASSIMP_BUILD_NO_Q3BSP_IMPORTER'])
|
||||
env_assimp.Append(CPPDEFINES=['ASSIMP_BUILD_NO_Q3D_IMPORTER'])
|
||||
env_assimp.Append(CPPDEFINES=['ASSIMP_BUILD_NO_RAW_IMPORTER'])
|
||||
env_assimp.Append(CPPDEFINES=['ASSIMP_BUILD_NO_SIB_IMPORTER'])
|
||||
env_assimp.Append(CPPDEFINES=['ASSIMP_BUILD_NO_SMD_IMPORTER'])
|
||||
env_assimp.Append(CPPDEFINES=['ASSIMP_BUILD_NO_STEP_IMPORTER'])
|
||||
env_assimp.Append(CPPDEFINES=['ASSIMP_BUILD_NO_STL_IMPORTER'])
|
||||
env_assimp.Append(CPPDEFINES=['ASSIMP_BUILD_NO_TERRAGEN_IMPORTER'])
|
||||
env_assimp.Append(CPPDEFINES=['ASSIMP_BUILD_NO_X3D_IMPORTER'])
|
||||
env_assimp.Append(CPPDEFINES=['ASSIMP_BUILD_NO_XGL_IMPORTER'])
|
||||
env_assimp.Append(CPPDEFINES=['ASSIMP_BUILD_NO_X_IMPORTER'])
|
||||
env_assimp.Append(CPPDEFINES=["ASSIMP_BUILD_NO_3D_IMPORTER"])
|
||||
env_assimp.Append(CPPDEFINES=["ASSIMP_BUILD_NO_3DS_IMPORTER"])
|
||||
env_assimp.Append(CPPDEFINES=["ASSIMP_BUILD_NO_3MF_IMPORTER"])
|
||||
env_assimp.Append(CPPDEFINES=["ASSIMP_BUILD_NO_AC_IMPORTER"])
|
||||
env_assimp.Append(CPPDEFINES=["ASSIMP_BUILD_NO_AMF_IMPORTER"])
|
||||
env_assimp.Append(CPPDEFINES=["ASSIMP_BUILD_NO_ASE_IMPORTER"])
|
||||
env_assimp.Append(CPPDEFINES=["ASSIMP_BUILD_NO_ASSBIN_IMPORTER"])
|
||||
env_assimp.Append(CPPDEFINES=["ASSIMP_BUILD_NO_B3D_IMPORTER"])
|
||||
env_assimp.Append(CPPDEFINES=["ASSIMP_BUILD_NO_BLEND_IMPORTER"])
|
||||
env_assimp.Append(CPPDEFINES=["ASSIMP_BUILD_NO_BVH_IMPORTER"])
|
||||
env_assimp.Append(CPPDEFINES=["ASSIMP_BUILD_NO_C4D_IMPORTER"])
|
||||
env_assimp.Append(CPPDEFINES=["ASSIMP_BUILD_NO_COB_IMPORTER"])
|
||||
env_assimp.Append(CPPDEFINES=["ASSIMP_BUILD_NO_COLLADA_IMPORTER"])
|
||||
env_assimp.Append(CPPDEFINES=["ASSIMP_BUILD_NO_CSM_IMPORTER"])
|
||||
env_assimp.Append(CPPDEFINES=["ASSIMP_BUILD_NO_DXF_IMPORTER"])
|
||||
env_assimp.Append(CPPDEFINES=["ASSIMP_BUILD_NO_GLTF2_IMPORTER"])
|
||||
env_assimp.Append(CPPDEFINES=["ASSIMP_BUILD_NO_GLTF_IMPORTER"])
|
||||
env_assimp.Append(CPPDEFINES=["ASSIMP_BUILD_NO_HMP_IMPORTER"])
|
||||
env_assimp.Append(CPPDEFINES=["ASSIMP_BUILD_NO_IFC_IMPORTER"])
|
||||
env_assimp.Append(CPPDEFINES=["ASSIMP_BUILD_NO_IRR_IMPORTER"])
|
||||
env_assimp.Append(CPPDEFINES=["ASSIMP_BUILD_NO_IRRMESH_IMPORTER"])
|
||||
env_assimp.Append(CPPDEFINES=["ASSIMP_BUILD_NO_LWO_IMPORTER"])
|
||||
env_assimp.Append(CPPDEFINES=["ASSIMP_BUILD_NO_LWS_IMPORTER"])
|
||||
env_assimp.Append(CPPDEFINES=["ASSIMP_BUILD_NO_M3D_IMPORTER"])
|
||||
env_assimp.Append(CPPDEFINES=["ASSIMP_BUILD_NO_MD2_IMPORTER"])
|
||||
env_assimp.Append(CPPDEFINES=["ASSIMP_BUILD_NO_MD3_IMPORTER"])
|
||||
env_assimp.Append(CPPDEFINES=["ASSIMP_BUILD_NO_MD5_IMPORTER"])
|
||||
env_assimp.Append(CPPDEFINES=["ASSIMP_BUILD_NO_MD5_IMPORTER"])
|
||||
env_assimp.Append(CPPDEFINES=["ASSIMP_BUILD_NO_MDC_IMPORTER"])
|
||||
env_assimp.Append(CPPDEFINES=["ASSIMP_BUILD_NO_MDL_IMPORTER"])
|
||||
env_assimp.Append(CPPDEFINES=["ASSIMP_BUILD_NO_MMD_IMPORTER"])
|
||||
env_assimp.Append(CPPDEFINES=["ASSIMP_BUILD_NO_MS3D_IMPORTER"])
|
||||
env_assimp.Append(CPPDEFINES=["ASSIMP_BUILD_NO_NDO_IMPORTER"])
|
||||
env_assimp.Append(CPPDEFINES=["ASSIMP_BUILD_NO_NFF_IMPORTER"])
|
||||
env_assimp.Append(CPPDEFINES=["ASSIMP_BUILD_NO_OBJ_IMPORTER"])
|
||||
env_assimp.Append(CPPDEFINES=["ASSIMP_BUILD_NO_OFF_IMPORTER"])
|
||||
env_assimp.Append(CPPDEFINES=["ASSIMP_BUILD_NO_OGRE_IMPORTER"])
|
||||
env_assimp.Append(CPPDEFINES=["ASSIMP_BUILD_NO_OPENGEX_IMPORTER"])
|
||||
env_assimp.Append(CPPDEFINES=["ASSIMP_BUILD_NO_PLY_IMPORTER"])
|
||||
env_assimp.Append(CPPDEFINES=["ASSIMP_BUILD_NO_Q3BSP_IMPORTER"])
|
||||
env_assimp.Append(CPPDEFINES=["ASSIMP_BUILD_NO_Q3D_IMPORTER"])
|
||||
env_assimp.Append(CPPDEFINES=["ASSIMP_BUILD_NO_RAW_IMPORTER"])
|
||||
env_assimp.Append(CPPDEFINES=["ASSIMP_BUILD_NO_SIB_IMPORTER"])
|
||||
env_assimp.Append(CPPDEFINES=["ASSIMP_BUILD_NO_SMD_IMPORTER"])
|
||||
env_assimp.Append(CPPDEFINES=["ASSIMP_BUILD_NO_STEP_IMPORTER"])
|
||||
env_assimp.Append(CPPDEFINES=["ASSIMP_BUILD_NO_STL_IMPORTER"])
|
||||
env_assimp.Append(CPPDEFINES=["ASSIMP_BUILD_NO_TERRAGEN_IMPORTER"])
|
||||
env_assimp.Append(CPPDEFINES=["ASSIMP_BUILD_NO_X3D_IMPORTER"])
|
||||
env_assimp.Append(CPPDEFINES=["ASSIMP_BUILD_NO_XGL_IMPORTER"])
|
||||
env_assimp.Append(CPPDEFINES=["ASSIMP_BUILD_NO_X_IMPORTER"])
|
||||
|
||||
if(env['platform'] == 'windows'):
|
||||
env_assimp.Append(CPPDEFINES=['PLATFORM_WINDOWS'])
|
||||
env_assimp.Append(CPPDEFINES=[('PLATFORM', 'WINDOWS')])
|
||||
elif(env['platform'] == 'linuxbsd'):
|
||||
env_assimp.Append(CPPDEFINES=['PLATFORM_LINUX'])
|
||||
env_assimp.Append(CPPDEFINES=[('PLATFORM', 'LINUX')])
|
||||
elif(env['platform'] == 'osx'):
|
||||
env_assimp.Append(CPPDEFINES=['PLATFORM_DARWIN'])
|
||||
env_assimp.Append(CPPDEFINES=[('PLATFORM', 'DARWIN')])
|
||||
if env["platform"] == "windows":
|
||||
env_assimp.Append(CPPDEFINES=["PLATFORM_WINDOWS"])
|
||||
env_assimp.Append(CPPDEFINES=[("PLATFORM", "WINDOWS")])
|
||||
elif env["platform"] == "linuxbsd":
|
||||
env_assimp.Append(CPPDEFINES=["PLATFORM_LINUX"])
|
||||
env_assimp.Append(CPPDEFINES=[("PLATFORM", "LINUX")])
|
||||
elif env["platform"] == "osx":
|
||||
env_assimp.Append(CPPDEFINES=["PLATFORM_DARWIN"])
|
||||
env_assimp.Append(CPPDEFINES=[("PLATFORM", "DARWIN")])
|
||||
|
||||
env_thirdparty = env_assimp.Clone()
|
||||
env_thirdparty.disable_warnings()
|
||||
env_thirdparty.add_source_files(env.modules_sources, Glob('#thirdparty/assimp/code/CApi/*.cpp'))
|
||||
env_thirdparty.add_source_files(env.modules_sources, Glob('#thirdparty/assimp/code/Common/*.cpp'))
|
||||
env_thirdparty.add_source_files(env.modules_sources, Glob('#thirdparty/assimp/code/PostProcessing/*.cpp'))
|
||||
env_thirdparty.add_source_files(env.modules_sources, Glob('#thirdparty/assimp/code/Material/*.cpp'))
|
||||
env_thirdparty.add_source_files(env.modules_sources, Glob('#thirdparty/assimp/code/FBX/*.cpp'))
|
||||
env_thirdparty.add_source_files(env.modules_sources, Glob("#thirdparty/assimp/code/CApi/*.cpp"))
|
||||
env_thirdparty.add_source_files(env.modules_sources, Glob("#thirdparty/assimp/code/Common/*.cpp"))
|
||||
env_thirdparty.add_source_files(env.modules_sources, Glob("#thirdparty/assimp/code/PostProcessing/*.cpp"))
|
||||
env_thirdparty.add_source_files(env.modules_sources, Glob("#thirdparty/assimp/code/Material/*.cpp"))
|
||||
env_thirdparty.add_source_files(env.modules_sources, Glob("#thirdparty/assimp/code/FBX/*.cpp"))
|
||||
|
||||
# Godot's own source files
|
||||
env_assimp.add_source_files(env.modules_sources, "*.cpp")
|
||||
|
|
|
|||
|
|
@ -1,5 +1,6 @@
|
|||
def can_build(env, platform):
|
||||
return env['tools']
|
||||
return env["tools"]
|
||||
|
||||
|
||||
def configure(env):
|
||||
pass
|
||||
|
|
|
|||
|
|
@ -1,7 +1,7 @@
|
|||
#!/usr/bin/env python
|
||||
|
||||
Import('env')
|
||||
Import('env_modules')
|
||||
Import("env")
|
||||
Import("env_modules")
|
||||
|
||||
env_basisu = env_modules.Clone()
|
||||
|
||||
|
|
@ -29,16 +29,18 @@ transcoder_sources = [thirdparty_dir + "transcoder/basisu_transcoder.cpp"]
|
|||
|
||||
# Treat Basis headers as system headers to avoid raising warnings. Not supported on MSVC.
|
||||
if not env.msvc:
|
||||
env_basisu.Append(CPPFLAGS=['-isystem', Dir(thirdparty_dir).path, '-isystem', Dir(thirdparty_dir + "transcoder").path])
|
||||
env_basisu.Append(
|
||||
CPPFLAGS=["-isystem", Dir(thirdparty_dir).path, "-isystem", Dir(thirdparty_dir + "transcoder").path]
|
||||
)
|
||||
else:
|
||||
env_basisu.Prepend(CPPPATH=[thirdparty_dir, thirdparty_dir + "transcoder"])
|
||||
|
||||
if env['target'] == "debug":
|
||||
if env["target"] == "debug":
|
||||
env_basisu.Append(CPPFLAGS=["-DBASISU_DEVEL_MESSAGES=1", "-DBASISD_ENABLE_DEBUG_FLAGS=1"])
|
||||
|
||||
env_thirdparty = env_basisu.Clone()
|
||||
env_thirdparty.disable_warnings()
|
||||
if env['tools']:
|
||||
if env["tools"]:
|
||||
env_thirdparty.add_source_files(env.modules_sources, tool_sources)
|
||||
env_thirdparty.add_source_files(env.modules_sources, transcoder_sources)
|
||||
|
||||
|
|
|
|||
|
|
@ -1,5 +1,6 @@
|
|||
def can_build(env, platform):
|
||||
return True
|
||||
|
||||
|
||||
def configure(env):
|
||||
pass
|
||||
|
|
|
|||
|
|
@ -1,7 +1,7 @@
|
|||
#!/usr/bin/env python
|
||||
|
||||
Import('env')
|
||||
Import('env_modules')
|
||||
Import("env")
|
||||
Import("env_modules")
|
||||
|
||||
env_bmp = env_modules.Clone()
|
||||
|
||||
|
|
|
|||
|
|
@ -1,5 +1,6 @@
|
|||
def can_build(env, platform):
|
||||
return True
|
||||
|
||||
|
||||
def configure(env):
|
||||
pass
|
||||
|
|
|
|||
|
|
@ -1,208 +1,203 @@
|
|||
#!/usr/bin/env python
|
||||
|
||||
Import('env')
|
||||
Import('env_modules')
|
||||
Import("env")
|
||||
Import("env_modules")
|
||||
|
||||
env_bullet = env_modules.Clone()
|
||||
|
||||
# Thirdparty source files
|
||||
|
||||
if env['builtin_bullet']:
|
||||
if env["builtin_bullet"]:
|
||||
# Build only version 2 for now (as of 2.89)
|
||||
# Sync file list with relevant upstream CMakeLists.txt for each folder.
|
||||
thirdparty_dir = "#thirdparty/bullet/"
|
||||
|
||||
bullet2_src = [
|
||||
# BulletCollision
|
||||
"BulletCollision/BroadphaseCollision/btAxisSweep3.cpp"
|
||||
, "BulletCollision/BroadphaseCollision/btBroadphaseProxy.cpp"
|
||||
, "BulletCollision/BroadphaseCollision/btCollisionAlgorithm.cpp"
|
||||
, "BulletCollision/BroadphaseCollision/btDbvt.cpp"
|
||||
, "BulletCollision/BroadphaseCollision/btDbvtBroadphase.cpp"
|
||||
, "BulletCollision/BroadphaseCollision/btDispatcher.cpp"
|
||||
, "BulletCollision/BroadphaseCollision/btOverlappingPairCache.cpp"
|
||||
, "BulletCollision/BroadphaseCollision/btQuantizedBvh.cpp"
|
||||
, "BulletCollision/BroadphaseCollision/btSimpleBroadphase.cpp"
|
||||
, "BulletCollision/CollisionDispatch/btActivatingCollisionAlgorithm.cpp"
|
||||
, "BulletCollision/CollisionDispatch/btBoxBoxCollisionAlgorithm.cpp"
|
||||
, "BulletCollision/CollisionDispatch/btBox2dBox2dCollisionAlgorithm.cpp"
|
||||
, "BulletCollision/CollisionDispatch/btBoxBoxDetector.cpp"
|
||||
, "BulletCollision/CollisionDispatch/btCollisionDispatcher.cpp"
|
||||
, "BulletCollision/CollisionDispatch/btCollisionDispatcherMt.cpp"
|
||||
, "BulletCollision/CollisionDispatch/btCollisionObject.cpp"
|
||||
, "BulletCollision/CollisionDispatch/btCollisionWorld.cpp"
|
||||
, "BulletCollision/CollisionDispatch/btCollisionWorldImporter.cpp"
|
||||
, "BulletCollision/CollisionDispatch/btCompoundCollisionAlgorithm.cpp"
|
||||
, "BulletCollision/CollisionDispatch/btCompoundCompoundCollisionAlgorithm.cpp"
|
||||
, "BulletCollision/CollisionDispatch/btConvexConcaveCollisionAlgorithm.cpp"
|
||||
, "BulletCollision/CollisionDispatch/btConvexConvexAlgorithm.cpp"
|
||||
, "BulletCollision/CollisionDispatch/btConvexPlaneCollisionAlgorithm.cpp"
|
||||
, "BulletCollision/CollisionDispatch/btConvex2dConvex2dAlgorithm.cpp"
|
||||
, "BulletCollision/CollisionDispatch/btDefaultCollisionConfiguration.cpp"
|
||||
, "BulletCollision/CollisionDispatch/btEmptyCollisionAlgorithm.cpp"
|
||||
, "BulletCollision/CollisionDispatch/btGhostObject.cpp"
|
||||
, "BulletCollision/CollisionDispatch/btHashedSimplePairCache.cpp"
|
||||
, "BulletCollision/CollisionDispatch/btInternalEdgeUtility.cpp"
|
||||
, "BulletCollision/CollisionDispatch/btManifoldResult.cpp"
|
||||
, "BulletCollision/CollisionDispatch/btSimulationIslandManager.cpp"
|
||||
, "BulletCollision/CollisionDispatch/btSphereBoxCollisionAlgorithm.cpp"
|
||||
, "BulletCollision/CollisionDispatch/btSphereSphereCollisionAlgorithm.cpp"
|
||||
, "BulletCollision/CollisionDispatch/btSphereTriangleCollisionAlgorithm.cpp"
|
||||
, "BulletCollision/CollisionDispatch/btUnionFind.cpp"
|
||||
, "BulletCollision/CollisionDispatch/SphereTriangleDetector.cpp"
|
||||
, "BulletCollision/CollisionShapes/btBoxShape.cpp"
|
||||
, "BulletCollision/CollisionShapes/btBox2dShape.cpp"
|
||||
, "BulletCollision/CollisionShapes/btBvhTriangleMeshShape.cpp"
|
||||
, "BulletCollision/CollisionShapes/btCapsuleShape.cpp"
|
||||
, "BulletCollision/CollisionShapes/btCollisionShape.cpp"
|
||||
, "BulletCollision/CollisionShapes/btCompoundShape.cpp"
|
||||
, "BulletCollision/CollisionShapes/btConcaveShape.cpp"
|
||||
, "BulletCollision/CollisionShapes/btConeShape.cpp"
|
||||
, "BulletCollision/CollisionShapes/btConvexHullShape.cpp"
|
||||
, "BulletCollision/CollisionShapes/btConvexInternalShape.cpp"
|
||||
, "BulletCollision/CollisionShapes/btConvexPointCloudShape.cpp"
|
||||
, "BulletCollision/CollisionShapes/btConvexPolyhedron.cpp"
|
||||
, "BulletCollision/CollisionShapes/btConvexShape.cpp"
|
||||
, "BulletCollision/CollisionShapes/btConvex2dShape.cpp"
|
||||
, "BulletCollision/CollisionShapes/btConvexTriangleMeshShape.cpp"
|
||||
, "BulletCollision/CollisionShapes/btCylinderShape.cpp"
|
||||
, "BulletCollision/CollisionShapes/btEmptyShape.cpp"
|
||||
, "BulletCollision/CollisionShapes/btHeightfieldTerrainShape.cpp"
|
||||
, "BulletCollision/CollisionShapes/btMiniSDF.cpp"
|
||||
, "BulletCollision/CollisionShapes/btMinkowskiSumShape.cpp"
|
||||
, "BulletCollision/CollisionShapes/btMultimaterialTriangleMeshShape.cpp"
|
||||
, "BulletCollision/CollisionShapes/btMultiSphereShape.cpp"
|
||||
, "BulletCollision/CollisionShapes/btOptimizedBvh.cpp"
|
||||
, "BulletCollision/CollisionShapes/btPolyhedralConvexShape.cpp"
|
||||
, "BulletCollision/CollisionShapes/btScaledBvhTriangleMeshShape.cpp"
|
||||
, "BulletCollision/CollisionShapes/btSdfCollisionShape.cpp"
|
||||
, "BulletCollision/CollisionShapes/btShapeHull.cpp"
|
||||
, "BulletCollision/CollisionShapes/btSphereShape.cpp"
|
||||
, "BulletCollision/CollisionShapes/btStaticPlaneShape.cpp"
|
||||
, "BulletCollision/CollisionShapes/btStridingMeshInterface.cpp"
|
||||
, "BulletCollision/CollisionShapes/btTetrahedronShape.cpp"
|
||||
, "BulletCollision/CollisionShapes/btTriangleBuffer.cpp"
|
||||
, "BulletCollision/CollisionShapes/btTriangleCallback.cpp"
|
||||
, "BulletCollision/CollisionShapes/btTriangleIndexVertexArray.cpp"
|
||||
, "BulletCollision/CollisionShapes/btTriangleIndexVertexMaterialArray.cpp"
|
||||
, "BulletCollision/CollisionShapes/btTriangleMesh.cpp"
|
||||
, "BulletCollision/CollisionShapes/btTriangleMeshShape.cpp"
|
||||
, "BulletCollision/CollisionShapes/btUniformScalingShape.cpp"
|
||||
, "BulletCollision/Gimpact/btContactProcessing.cpp"
|
||||
, "BulletCollision/Gimpact/btGenericPoolAllocator.cpp"
|
||||
, "BulletCollision/Gimpact/btGImpactBvh.cpp"
|
||||
, "BulletCollision/Gimpact/btGImpactCollisionAlgorithm.cpp"
|
||||
, "BulletCollision/Gimpact/btGImpactQuantizedBvh.cpp"
|
||||
, "BulletCollision/Gimpact/btGImpactShape.cpp"
|
||||
, "BulletCollision/Gimpact/btTriangleShapeEx.cpp"
|
||||
, "BulletCollision/Gimpact/gim_box_set.cpp"
|
||||
, "BulletCollision/Gimpact/gim_contact.cpp"
|
||||
, "BulletCollision/Gimpact/gim_memory.cpp"
|
||||
, "BulletCollision/Gimpact/gim_tri_collision.cpp"
|
||||
, "BulletCollision/NarrowPhaseCollision/btContinuousConvexCollision.cpp"
|
||||
, "BulletCollision/NarrowPhaseCollision/btConvexCast.cpp"
|
||||
, "BulletCollision/NarrowPhaseCollision/btGjkConvexCast.cpp"
|
||||
, "BulletCollision/NarrowPhaseCollision/btGjkEpa2.cpp"
|
||||
, "BulletCollision/NarrowPhaseCollision/btGjkEpaPenetrationDepthSolver.cpp"
|
||||
, "BulletCollision/NarrowPhaseCollision/btGjkPairDetector.cpp"
|
||||
, "BulletCollision/NarrowPhaseCollision/btMinkowskiPenetrationDepthSolver.cpp"
|
||||
, "BulletCollision/NarrowPhaseCollision/btPersistentManifold.cpp"
|
||||
, "BulletCollision/NarrowPhaseCollision/btRaycastCallback.cpp"
|
||||
, "BulletCollision/NarrowPhaseCollision/btSubSimplexConvexCast.cpp"
|
||||
, "BulletCollision/NarrowPhaseCollision/btVoronoiSimplexSolver.cpp"
|
||||
, "BulletCollision/NarrowPhaseCollision/btPolyhedralContactClipping.cpp"
|
||||
|
||||
"BulletCollision/BroadphaseCollision/btAxisSweep3.cpp",
|
||||
"BulletCollision/BroadphaseCollision/btBroadphaseProxy.cpp",
|
||||
"BulletCollision/BroadphaseCollision/btCollisionAlgorithm.cpp",
|
||||
"BulletCollision/BroadphaseCollision/btDbvt.cpp",
|
||||
"BulletCollision/BroadphaseCollision/btDbvtBroadphase.cpp",
|
||||
"BulletCollision/BroadphaseCollision/btDispatcher.cpp",
|
||||
"BulletCollision/BroadphaseCollision/btOverlappingPairCache.cpp",
|
||||
"BulletCollision/BroadphaseCollision/btQuantizedBvh.cpp",
|
||||
"BulletCollision/BroadphaseCollision/btSimpleBroadphase.cpp",
|
||||
"BulletCollision/CollisionDispatch/btActivatingCollisionAlgorithm.cpp",
|
||||
"BulletCollision/CollisionDispatch/btBoxBoxCollisionAlgorithm.cpp",
|
||||
"BulletCollision/CollisionDispatch/btBox2dBox2dCollisionAlgorithm.cpp",
|
||||
"BulletCollision/CollisionDispatch/btBoxBoxDetector.cpp",
|
||||
"BulletCollision/CollisionDispatch/btCollisionDispatcher.cpp",
|
||||
"BulletCollision/CollisionDispatch/btCollisionDispatcherMt.cpp",
|
||||
"BulletCollision/CollisionDispatch/btCollisionObject.cpp",
|
||||
"BulletCollision/CollisionDispatch/btCollisionWorld.cpp",
|
||||
"BulletCollision/CollisionDispatch/btCollisionWorldImporter.cpp",
|
||||
"BulletCollision/CollisionDispatch/btCompoundCollisionAlgorithm.cpp",
|
||||
"BulletCollision/CollisionDispatch/btCompoundCompoundCollisionAlgorithm.cpp",
|
||||
"BulletCollision/CollisionDispatch/btConvexConcaveCollisionAlgorithm.cpp",
|
||||
"BulletCollision/CollisionDispatch/btConvexConvexAlgorithm.cpp",
|
||||
"BulletCollision/CollisionDispatch/btConvexPlaneCollisionAlgorithm.cpp",
|
||||
"BulletCollision/CollisionDispatch/btConvex2dConvex2dAlgorithm.cpp",
|
||||
"BulletCollision/CollisionDispatch/btDefaultCollisionConfiguration.cpp",
|
||||
"BulletCollision/CollisionDispatch/btEmptyCollisionAlgorithm.cpp",
|
||||
"BulletCollision/CollisionDispatch/btGhostObject.cpp",
|
||||
"BulletCollision/CollisionDispatch/btHashedSimplePairCache.cpp",
|
||||
"BulletCollision/CollisionDispatch/btInternalEdgeUtility.cpp",
|
||||
"BulletCollision/CollisionDispatch/btManifoldResult.cpp",
|
||||
"BulletCollision/CollisionDispatch/btSimulationIslandManager.cpp",
|
||||
"BulletCollision/CollisionDispatch/btSphereBoxCollisionAlgorithm.cpp",
|
||||
"BulletCollision/CollisionDispatch/btSphereSphereCollisionAlgorithm.cpp",
|
||||
"BulletCollision/CollisionDispatch/btSphereTriangleCollisionAlgorithm.cpp",
|
||||
"BulletCollision/CollisionDispatch/btUnionFind.cpp",
|
||||
"BulletCollision/CollisionDispatch/SphereTriangleDetector.cpp",
|
||||
"BulletCollision/CollisionShapes/btBoxShape.cpp",
|
||||
"BulletCollision/CollisionShapes/btBox2dShape.cpp",
|
||||
"BulletCollision/CollisionShapes/btBvhTriangleMeshShape.cpp",
|
||||
"BulletCollision/CollisionShapes/btCapsuleShape.cpp",
|
||||
"BulletCollision/CollisionShapes/btCollisionShape.cpp",
|
||||
"BulletCollision/CollisionShapes/btCompoundShape.cpp",
|
||||
"BulletCollision/CollisionShapes/btConcaveShape.cpp",
|
||||
"BulletCollision/CollisionShapes/btConeShape.cpp",
|
||||
"BulletCollision/CollisionShapes/btConvexHullShape.cpp",
|
||||
"BulletCollision/CollisionShapes/btConvexInternalShape.cpp",
|
||||
"BulletCollision/CollisionShapes/btConvexPointCloudShape.cpp",
|
||||
"BulletCollision/CollisionShapes/btConvexPolyhedron.cpp",
|
||||
"BulletCollision/CollisionShapes/btConvexShape.cpp",
|
||||
"BulletCollision/CollisionShapes/btConvex2dShape.cpp",
|
||||
"BulletCollision/CollisionShapes/btConvexTriangleMeshShape.cpp",
|
||||
"BulletCollision/CollisionShapes/btCylinderShape.cpp",
|
||||
"BulletCollision/CollisionShapes/btEmptyShape.cpp",
|
||||
"BulletCollision/CollisionShapes/btHeightfieldTerrainShape.cpp",
|
||||
"BulletCollision/CollisionShapes/btMiniSDF.cpp",
|
||||
"BulletCollision/CollisionShapes/btMinkowskiSumShape.cpp",
|
||||
"BulletCollision/CollisionShapes/btMultimaterialTriangleMeshShape.cpp",
|
||||
"BulletCollision/CollisionShapes/btMultiSphereShape.cpp",
|
||||
"BulletCollision/CollisionShapes/btOptimizedBvh.cpp",
|
||||
"BulletCollision/CollisionShapes/btPolyhedralConvexShape.cpp",
|
||||
"BulletCollision/CollisionShapes/btScaledBvhTriangleMeshShape.cpp",
|
||||
"BulletCollision/CollisionShapes/btSdfCollisionShape.cpp",
|
||||
"BulletCollision/CollisionShapes/btShapeHull.cpp",
|
||||
"BulletCollision/CollisionShapes/btSphereShape.cpp",
|
||||
"BulletCollision/CollisionShapes/btStaticPlaneShape.cpp",
|
||||
"BulletCollision/CollisionShapes/btStridingMeshInterface.cpp",
|
||||
"BulletCollision/CollisionShapes/btTetrahedronShape.cpp",
|
||||
"BulletCollision/CollisionShapes/btTriangleBuffer.cpp",
|
||||
"BulletCollision/CollisionShapes/btTriangleCallback.cpp",
|
||||
"BulletCollision/CollisionShapes/btTriangleIndexVertexArray.cpp",
|
||||
"BulletCollision/CollisionShapes/btTriangleIndexVertexMaterialArray.cpp",
|
||||
"BulletCollision/CollisionShapes/btTriangleMesh.cpp",
|
||||
"BulletCollision/CollisionShapes/btTriangleMeshShape.cpp",
|
||||
"BulletCollision/CollisionShapes/btUniformScalingShape.cpp",
|
||||
"BulletCollision/Gimpact/btContactProcessing.cpp",
|
||||
"BulletCollision/Gimpact/btGenericPoolAllocator.cpp",
|
||||
"BulletCollision/Gimpact/btGImpactBvh.cpp",
|
||||
"BulletCollision/Gimpact/btGImpactCollisionAlgorithm.cpp",
|
||||
"BulletCollision/Gimpact/btGImpactQuantizedBvh.cpp",
|
||||
"BulletCollision/Gimpact/btGImpactShape.cpp",
|
||||
"BulletCollision/Gimpact/btTriangleShapeEx.cpp",
|
||||
"BulletCollision/Gimpact/gim_box_set.cpp",
|
||||
"BulletCollision/Gimpact/gim_contact.cpp",
|
||||
"BulletCollision/Gimpact/gim_memory.cpp",
|
||||
"BulletCollision/Gimpact/gim_tri_collision.cpp",
|
||||
"BulletCollision/NarrowPhaseCollision/btContinuousConvexCollision.cpp",
|
||||
"BulletCollision/NarrowPhaseCollision/btConvexCast.cpp",
|
||||
"BulletCollision/NarrowPhaseCollision/btGjkConvexCast.cpp",
|
||||
"BulletCollision/NarrowPhaseCollision/btGjkEpa2.cpp",
|
||||
"BulletCollision/NarrowPhaseCollision/btGjkEpaPenetrationDepthSolver.cpp",
|
||||
"BulletCollision/NarrowPhaseCollision/btGjkPairDetector.cpp",
|
||||
"BulletCollision/NarrowPhaseCollision/btMinkowskiPenetrationDepthSolver.cpp",
|
||||
"BulletCollision/NarrowPhaseCollision/btPersistentManifold.cpp",
|
||||
"BulletCollision/NarrowPhaseCollision/btRaycastCallback.cpp",
|
||||
"BulletCollision/NarrowPhaseCollision/btSubSimplexConvexCast.cpp",
|
||||
"BulletCollision/NarrowPhaseCollision/btVoronoiSimplexSolver.cpp",
|
||||
"BulletCollision/NarrowPhaseCollision/btPolyhedralContactClipping.cpp",
|
||||
# BulletDynamics
|
||||
, "BulletDynamics/Character/btKinematicCharacterController.cpp"
|
||||
, "BulletDynamics/ConstraintSolver/btConeTwistConstraint.cpp"
|
||||
, "BulletDynamics/ConstraintSolver/btContactConstraint.cpp"
|
||||
, "BulletDynamics/ConstraintSolver/btFixedConstraint.cpp"
|
||||
, "BulletDynamics/ConstraintSolver/btGearConstraint.cpp"
|
||||
, "BulletDynamics/ConstraintSolver/btGeneric6DofConstraint.cpp"
|
||||
, "BulletDynamics/ConstraintSolver/btGeneric6DofSpringConstraint.cpp"
|
||||
, "BulletDynamics/ConstraintSolver/btGeneric6DofSpring2Constraint.cpp"
|
||||
, "BulletDynamics/ConstraintSolver/btHinge2Constraint.cpp"
|
||||
, "BulletDynamics/ConstraintSolver/btHingeConstraint.cpp"
|
||||
, "BulletDynamics/ConstraintSolver/btPoint2PointConstraint.cpp"
|
||||
, "BulletDynamics/ConstraintSolver/btSequentialImpulseConstraintSolver.cpp"
|
||||
, "BulletDynamics/ConstraintSolver/btSequentialImpulseConstraintSolverMt.cpp"
|
||||
, "BulletDynamics/ConstraintSolver/btBatchedConstraints.cpp"
|
||||
, "BulletDynamics/ConstraintSolver/btNNCGConstraintSolver.cpp"
|
||||
, "BulletDynamics/ConstraintSolver/btSliderConstraint.cpp"
|
||||
, "BulletDynamics/ConstraintSolver/btSolve2LinearConstraint.cpp"
|
||||
, "BulletDynamics/ConstraintSolver/btTypedConstraint.cpp"
|
||||
, "BulletDynamics/ConstraintSolver/btUniversalConstraint.cpp"
|
||||
, "BulletDynamics/Dynamics/btDiscreteDynamicsWorld.cpp"
|
||||
, "BulletDynamics/Dynamics/btDiscreteDynamicsWorldMt.cpp"
|
||||
, "BulletDynamics/Dynamics/btSimulationIslandManagerMt.cpp"
|
||||
, "BulletDynamics/Dynamics/btRigidBody.cpp"
|
||||
, "BulletDynamics/Dynamics/btSimpleDynamicsWorld.cpp"
|
||||
#, "BulletDynamics/Dynamics/Bullet-C-API.cpp"
|
||||
, "BulletDynamics/Vehicle/btRaycastVehicle.cpp"
|
||||
, "BulletDynamics/Vehicle/btWheelInfo.cpp"
|
||||
, "BulletDynamics/Featherstone/btMultiBody.cpp"
|
||||
, "BulletDynamics/Featherstone/btMultiBodyConstraint.cpp"
|
||||
, "BulletDynamics/Featherstone/btMultiBodyConstraintSolver.cpp"
|
||||
, "BulletDynamics/Featherstone/btMultiBodyDynamicsWorld.cpp"
|
||||
, "BulletDynamics/Featherstone/btMultiBodyFixedConstraint.cpp"
|
||||
, "BulletDynamics/Featherstone/btMultiBodyGearConstraint.cpp"
|
||||
, "BulletDynamics/Featherstone/btMultiBodyJointLimitConstraint.cpp"
|
||||
, "BulletDynamics/Featherstone/btMultiBodyJointMotor.cpp"
|
||||
, "BulletDynamics/Featherstone/btMultiBodyMLCPConstraintSolver.cpp"
|
||||
, "BulletDynamics/Featherstone/btMultiBodyPoint2Point.cpp"
|
||||
, "BulletDynamics/Featherstone/btMultiBodySliderConstraint.cpp"
|
||||
, "BulletDynamics/Featherstone/btMultiBodySphericalJointMotor.cpp"
|
||||
, "BulletDynamics/MLCPSolvers/btDantzigLCP.cpp"
|
||||
, "BulletDynamics/MLCPSolvers/btMLCPSolver.cpp"
|
||||
, "BulletDynamics/MLCPSolvers/btLemkeAlgorithm.cpp"
|
||||
|
||||
"BulletDynamics/Character/btKinematicCharacterController.cpp",
|
||||
"BulletDynamics/ConstraintSolver/btConeTwistConstraint.cpp",
|
||||
"BulletDynamics/ConstraintSolver/btContactConstraint.cpp",
|
||||
"BulletDynamics/ConstraintSolver/btFixedConstraint.cpp",
|
||||
"BulletDynamics/ConstraintSolver/btGearConstraint.cpp",
|
||||
"BulletDynamics/ConstraintSolver/btGeneric6DofConstraint.cpp",
|
||||
"BulletDynamics/ConstraintSolver/btGeneric6DofSpringConstraint.cpp",
|
||||
"BulletDynamics/ConstraintSolver/btGeneric6DofSpring2Constraint.cpp",
|
||||
"BulletDynamics/ConstraintSolver/btHinge2Constraint.cpp",
|
||||
"BulletDynamics/ConstraintSolver/btHingeConstraint.cpp",
|
||||
"BulletDynamics/ConstraintSolver/btPoint2PointConstraint.cpp",
|
||||
"BulletDynamics/ConstraintSolver/btSequentialImpulseConstraintSolver.cpp",
|
||||
"BulletDynamics/ConstraintSolver/btSequentialImpulseConstraintSolverMt.cpp",
|
||||
"BulletDynamics/ConstraintSolver/btBatchedConstraints.cpp",
|
||||
"BulletDynamics/ConstraintSolver/btNNCGConstraintSolver.cpp",
|
||||
"BulletDynamics/ConstraintSolver/btSliderConstraint.cpp",
|
||||
"BulletDynamics/ConstraintSolver/btSolve2LinearConstraint.cpp",
|
||||
"BulletDynamics/ConstraintSolver/btTypedConstraint.cpp",
|
||||
"BulletDynamics/ConstraintSolver/btUniversalConstraint.cpp",
|
||||
"BulletDynamics/Dynamics/btDiscreteDynamicsWorld.cpp",
|
||||
"BulletDynamics/Dynamics/btDiscreteDynamicsWorldMt.cpp",
|
||||
"BulletDynamics/Dynamics/btSimulationIslandManagerMt.cpp",
|
||||
"BulletDynamics/Dynamics/btRigidBody.cpp",
|
||||
"BulletDynamics/Dynamics/btSimpleDynamicsWorld.cpp",
|
||||
# "BulletDynamics/Dynamics/Bullet-C-API.cpp",
|
||||
"BulletDynamics/Vehicle/btRaycastVehicle.cpp",
|
||||
"BulletDynamics/Vehicle/btWheelInfo.cpp",
|
||||
"BulletDynamics/Featherstone/btMultiBody.cpp",
|
||||
"BulletDynamics/Featherstone/btMultiBodyConstraint.cpp",
|
||||
"BulletDynamics/Featherstone/btMultiBodyConstraintSolver.cpp",
|
||||
"BulletDynamics/Featherstone/btMultiBodyDynamicsWorld.cpp",
|
||||
"BulletDynamics/Featherstone/btMultiBodyFixedConstraint.cpp",
|
||||
"BulletDynamics/Featherstone/btMultiBodyGearConstraint.cpp",
|
||||
"BulletDynamics/Featherstone/btMultiBodyJointLimitConstraint.cpp",
|
||||
"BulletDynamics/Featherstone/btMultiBodyJointMotor.cpp",
|
||||
"BulletDynamics/Featherstone/btMultiBodyMLCPConstraintSolver.cpp",
|
||||
"BulletDynamics/Featherstone/btMultiBodyPoint2Point.cpp",
|
||||
"BulletDynamics/Featherstone/btMultiBodySliderConstraint.cpp",
|
||||
"BulletDynamics/Featherstone/btMultiBodySphericalJointMotor.cpp",
|
||||
"BulletDynamics/MLCPSolvers/btDantzigLCP.cpp",
|
||||
"BulletDynamics/MLCPSolvers/btMLCPSolver.cpp",
|
||||
"BulletDynamics/MLCPSolvers/btLemkeAlgorithm.cpp",
|
||||
# BulletInverseDynamics
|
||||
, "BulletInverseDynamics/IDMath.cpp"
|
||||
, "BulletInverseDynamics/MultiBodyTree.cpp"
|
||||
, "BulletInverseDynamics/details/MultiBodyTreeInitCache.cpp"
|
||||
, "BulletInverseDynamics/details/MultiBodyTreeImpl.cpp"
|
||||
|
||||
"BulletInverseDynamics/IDMath.cpp",
|
||||
"BulletInverseDynamics/MultiBodyTree.cpp",
|
||||
"BulletInverseDynamics/details/MultiBodyTreeInitCache.cpp",
|
||||
"BulletInverseDynamics/details/MultiBodyTreeImpl.cpp",
|
||||
# BulletSoftBody
|
||||
, "BulletSoftBody/btSoftBody.cpp"
|
||||
, "BulletSoftBody/btSoftBodyConcaveCollisionAlgorithm.cpp"
|
||||
, "BulletSoftBody/btSoftBodyHelpers.cpp"
|
||||
, "BulletSoftBody/btSoftBodyRigidBodyCollisionConfiguration.cpp"
|
||||
, "BulletSoftBody/btSoftRigidCollisionAlgorithm.cpp"
|
||||
, "BulletSoftBody/btSoftRigidDynamicsWorld.cpp"
|
||||
, "BulletSoftBody/btSoftMultiBodyDynamicsWorld.cpp"
|
||||
, "BulletSoftBody/btSoftSoftCollisionAlgorithm.cpp"
|
||||
, "BulletSoftBody/btDefaultSoftBodySolver.cpp"
|
||||
, "BulletSoftBody/btDeformableBackwardEulerObjective.cpp"
|
||||
, "BulletSoftBody/btDeformableBodySolver.cpp"
|
||||
, "BulletSoftBody/btDeformableMultiBodyConstraintSolver.cpp"
|
||||
, "BulletSoftBody/btDeformableContactProjection.cpp"
|
||||
, "BulletSoftBody/btDeformableMultiBodyDynamicsWorld.cpp"
|
||||
, "BulletSoftBody/btDeformableContactConstraint.cpp"
|
||||
|
||||
"BulletSoftBody/btSoftBody.cpp",
|
||||
"BulletSoftBody/btSoftBodyConcaveCollisionAlgorithm.cpp",
|
||||
"BulletSoftBody/btSoftBodyHelpers.cpp",
|
||||
"BulletSoftBody/btSoftBodyRigidBodyCollisionConfiguration.cpp",
|
||||
"BulletSoftBody/btSoftRigidCollisionAlgorithm.cpp",
|
||||
"BulletSoftBody/btSoftRigidDynamicsWorld.cpp",
|
||||
"BulletSoftBody/btSoftMultiBodyDynamicsWorld.cpp",
|
||||
"BulletSoftBody/btSoftSoftCollisionAlgorithm.cpp",
|
||||
"BulletSoftBody/btDefaultSoftBodySolver.cpp",
|
||||
"BulletSoftBody/btDeformableBackwardEulerObjective.cpp",
|
||||
"BulletSoftBody/btDeformableBodySolver.cpp",
|
||||
"BulletSoftBody/btDeformableMultiBodyConstraintSolver.cpp",
|
||||
"BulletSoftBody/btDeformableContactProjection.cpp",
|
||||
"BulletSoftBody/btDeformableMultiBodyDynamicsWorld.cpp",
|
||||
"BulletSoftBody/btDeformableContactConstraint.cpp",
|
||||
# clew
|
||||
, "clew/clew.c"
|
||||
|
||||
"clew/clew.c",
|
||||
# LinearMath
|
||||
, "LinearMath/btAlignedAllocator.cpp"
|
||||
, "LinearMath/btConvexHull.cpp"
|
||||
, "LinearMath/btConvexHullComputer.cpp"
|
||||
, "LinearMath/btGeometryUtil.cpp"
|
||||
, "LinearMath/btPolarDecomposition.cpp"
|
||||
, "LinearMath/btQuickprof.cpp"
|
||||
, "LinearMath/btSerializer.cpp"
|
||||
, "LinearMath/btSerializer64.cpp"
|
||||
, "LinearMath/btThreads.cpp"
|
||||
, "LinearMath/btVector3.cpp"
|
||||
, "LinearMath/TaskScheduler/btTaskScheduler.cpp"
|
||||
, "LinearMath/TaskScheduler/btThreadSupportPosix.cpp"
|
||||
, "LinearMath/TaskScheduler/btThreadSupportWin32.cpp"
|
||||
"LinearMath/btAlignedAllocator.cpp",
|
||||
"LinearMath/btConvexHull.cpp",
|
||||
"LinearMath/btConvexHullComputer.cpp",
|
||||
"LinearMath/btGeometryUtil.cpp",
|
||||
"LinearMath/btPolarDecomposition.cpp",
|
||||
"LinearMath/btQuickprof.cpp",
|
||||
"LinearMath/btSerializer.cpp",
|
||||
"LinearMath/btSerializer64.cpp",
|
||||
"LinearMath/btThreads.cpp",
|
||||
"LinearMath/btVector3.cpp",
|
||||
"LinearMath/TaskScheduler/btTaskScheduler.cpp",
|
||||
"LinearMath/TaskScheduler/btThreadSupportPosix.cpp",
|
||||
"LinearMath/TaskScheduler/btThreadSupportWin32.cpp",
|
||||
]
|
||||
|
||||
thirdparty_sources = [thirdparty_dir + file for file in bullet2_src]
|
||||
|
||||
# Treat Bullet headers as system headers to avoid raising warnings. Not supported on MSVC.
|
||||
if not env.msvc:
|
||||
env_bullet.Append(CPPFLAGS=['-isystem', Dir(thirdparty_dir).path])
|
||||
env_bullet.Append(CPPFLAGS=["-isystem", Dir(thirdparty_dir).path])
|
||||
else:
|
||||
env_bullet.Prepend(CPPPATH=[thirdparty_dir])
|
||||
# if env['target'] == "debug" or env['target'] == "release_debug":
|
||||
|
|
|
|||
|
|
@ -1,14 +1,17 @@
|
|||
def can_build(env, platform):
|
||||
return True
|
||||
|
||||
|
||||
def configure(env):
|
||||
pass
|
||||
|
||||
|
||||
def get_doc_classes():
|
||||
return [
|
||||
"BulletPhysicsDirectBodyState",
|
||||
"BulletPhysicsServer",
|
||||
]
|
||||
|
||||
|
||||
def get_doc_path():
|
||||
return "doc_classes"
|
||||
|
|
|
|||
|
|
@ -1,7 +1,7 @@
|
|||
#!/usr/bin/env python
|
||||
|
||||
Import('env')
|
||||
Import('env_modules')
|
||||
Import("env")
|
||||
Import("env_modules")
|
||||
|
||||
env_camera = env_modules.Clone()
|
||||
|
||||
|
|
@ -10,7 +10,7 @@ if env["platform"] == "iphone":
|
|||
modules_sources = []
|
||||
env_camera.add_source_files(modules_sources, "register_types.cpp")
|
||||
env_camera.add_source_files(modules_sources, "camera_ios.mm")
|
||||
mod_lib = env_modules.add_library('#bin/libgodot_camera_module' + env['LIBSUFFIX'], modules_sources)
|
||||
mod_lib = env_modules.add_library("#bin/libgodot_camera_module" + env["LIBSUFFIX"], modules_sources)
|
||||
|
||||
elif env["platform"] == "windows":
|
||||
env_camera.add_source_files(env.modules_sources, "register_types.cpp")
|
||||
|
|
@ -19,4 +19,3 @@ elif env["platform"] == "windows":
|
|||
elif env["platform"] == "osx":
|
||||
env_camera.add_source_files(env.modules_sources, "register_types.cpp")
|
||||
env_camera.add_source_files(env.modules_sources, "camera_osx.mm")
|
||||
|
||||
|
|
|
|||
|
|
@ -1,5 +1,6 @@
|
|||
def can_build(env, platform):
|
||||
return platform == 'iphone' or platform == 'osx' or platform == 'windows'
|
||||
return platform == "iphone" or platform == "osx" or platform == "windows"
|
||||
|
||||
|
||||
def configure(env):
|
||||
pass
|
||||
|
|
|
|||
|
|
@ -1,7 +1,7 @@
|
|||
#!/usr/bin/env python
|
||||
|
||||
Import('env')
|
||||
Import('env_modules')
|
||||
Import("env")
|
||||
Import("env_modules")
|
||||
|
||||
env_csg = env_modules.Clone()
|
||||
|
||||
|
|
|
|||
|
|
@ -1,9 +1,11 @@
|
|||
def can_build(env, platform):
|
||||
return True
|
||||
|
||||
|
||||
def configure(env):
|
||||
pass
|
||||
|
||||
|
||||
def get_doc_classes():
|
||||
return [
|
||||
"CSGBox",
|
||||
|
|
@ -17,5 +19,6 @@ def get_doc_classes():
|
|||
"CSGTorus",
|
||||
]
|
||||
|
||||
|
||||
def get_doc_path():
|
||||
return "doc_classes"
|
||||
|
|
|
|||
|
|
@ -1,14 +1,14 @@
|
|||
#!/usr/bin/env python
|
||||
|
||||
Import('env')
|
||||
Import('env_modules')
|
||||
Import("env")
|
||||
Import("env_modules")
|
||||
|
||||
env_cvtt = env_modules.Clone()
|
||||
|
||||
# Thirdparty source files
|
||||
thirdparty_dir = "#thirdparty/cvtt/"
|
||||
thirdparty_sources = [
|
||||
"ConvectionKernels.cpp"
|
||||
"ConvectionKernels.cpp",
|
||||
]
|
||||
|
||||
thirdparty_sources = [thirdparty_dir + file for file in thirdparty_sources]
|
||||
|
|
|
|||
|
|
@ -1,5 +1,6 @@
|
|||
def can_build(env, platform):
|
||||
return env['tools']
|
||||
return env["tools"]
|
||||
|
||||
|
||||
def configure(env):
|
||||
pass
|
||||
|
|
|
|||
|
|
@ -1,7 +1,7 @@
|
|||
#!/usr/bin/env python
|
||||
|
||||
Import('env')
|
||||
Import('env_modules')
|
||||
Import("env")
|
||||
Import("env_modules")
|
||||
|
||||
env_dds = env_modules.Clone()
|
||||
|
||||
|
|
|
|||
|
|
@ -1,5 +1,6 @@
|
|||
def can_build(env, platform):
|
||||
return True
|
||||
|
||||
|
||||
def configure(env):
|
||||
pass
|
||||
|
|
|
|||
|
|
@ -1,13 +1,13 @@
|
|||
#!/usr/bin/env python
|
||||
|
||||
Import('env')
|
||||
Import('env_modules')
|
||||
Import("env")
|
||||
Import("env_modules")
|
||||
|
||||
env_enet = env_modules.Clone()
|
||||
|
||||
# Thirdparty source files
|
||||
|
||||
if env['builtin_enet']:
|
||||
if env["builtin_enet"]:
|
||||
thirdparty_dir = "#thirdparty/enet/"
|
||||
thirdparty_sources = [
|
||||
"godot.cpp",
|
||||
|
|
|
|||
|
|
@ -1,13 +1,16 @@
|
|||
def can_build(env, platform):
|
||||
return True
|
||||
|
||||
|
||||
def configure(env):
|
||||
pass
|
||||
|
||||
|
||||
def get_doc_classes():
|
||||
return [
|
||||
"NetworkedMultiplayerENet",
|
||||
]
|
||||
|
||||
|
||||
def get_doc_path():
|
||||
return "doc_classes"
|
||||
|
|
|
|||
|
|
@ -1,7 +1,7 @@
|
|||
#!/usr/bin/env python
|
||||
|
||||
Import('env')
|
||||
Import('env_modules')
|
||||
Import("env")
|
||||
Import("env_modules")
|
||||
|
||||
env_etc = env_modules.Clone()
|
||||
|
||||
|
|
|
|||
|
|
@ -1,5 +1,6 @@
|
|||
def can_build(env, platform):
|
||||
return env['tools']
|
||||
return env["tools"]
|
||||
|
||||
|
||||
def configure(env):
|
||||
pass
|
||||
|
|
|
|||
|
|
@ -1,12 +1,12 @@
|
|||
#!/usr/bin/env python
|
||||
|
||||
Import('env')
|
||||
Import('env_modules')
|
||||
Import("env")
|
||||
Import("env_modules")
|
||||
|
||||
env_freetype = env_modules.Clone()
|
||||
|
||||
# Thirdparty source files
|
||||
if env['builtin_freetype']:
|
||||
if env["builtin_freetype"]:
|
||||
thirdparty_dir = "#thirdparty/freetype/"
|
||||
thirdparty_sources = [
|
||||
"src/autofit/autofit.c",
|
||||
|
|
@ -53,31 +53,31 @@ if env['builtin_freetype']:
|
|||
]
|
||||
thirdparty_sources = [thirdparty_dir + file for file in thirdparty_sources]
|
||||
|
||||
if env['platform'] == 'uwp':
|
||||
if env["platform"] == "uwp":
|
||||
# Include header for UWP to fix build issues
|
||||
env_freetype.Append(CCFLAGS=['/FI', '"modules/freetype/uwpdef.h"'])
|
||||
env_freetype.Append(CCFLAGS=["/FI", '"modules/freetype/uwpdef.h"'])
|
||||
# Globally too, as freetype is used in scene (see bottom)
|
||||
env.Append(CCFLAGS=['/FI', '"modules/freetype/uwpdef.h"'])
|
||||
env.Append(CCFLAGS=["/FI", '"modules/freetype/uwpdef.h"'])
|
||||
|
||||
env_freetype.Prepend(CPPPATH=[thirdparty_dir + "/include"])
|
||||
# Also needed in main env for scene/
|
||||
env.Prepend(CPPPATH=[thirdparty_dir + "/include"])
|
||||
|
||||
env_freetype.Append(CPPDEFINES=['FT2_BUILD_LIBRARY', 'FT_CONFIG_OPTION_USE_PNG'])
|
||||
if (env['target'] == 'debug'):
|
||||
env_freetype.Append(CPPDEFINES=['ZLIB_DEBUG'])
|
||||
env_freetype.Append(CPPDEFINES=["FT2_BUILD_LIBRARY", "FT_CONFIG_OPTION_USE_PNG"])
|
||||
if env["target"] == "debug":
|
||||
env_freetype.Append(CPPDEFINES=["ZLIB_DEBUG"])
|
||||
|
||||
# Also requires libpng headers
|
||||
if env['builtin_libpng']:
|
||||
if env["builtin_libpng"]:
|
||||
env_freetype.Prepend(CPPPATH=["#thirdparty/libpng"])
|
||||
|
||||
sfnt = thirdparty_dir + 'src/sfnt/sfnt.c'
|
||||
sfnt = thirdparty_dir + "src/sfnt/sfnt.c"
|
||||
# Must be done after all CPPDEFINES are being set so we can copy them.
|
||||
if env['platform'] == 'javascript':
|
||||
if env["platform"] == "javascript":
|
||||
# Forcibly undefine this macro so SIMD is not used in this file,
|
||||
# since currently unsupported in WASM
|
||||
tmp_env = env_freetype.Clone()
|
||||
tmp_env.Append(CPPFLAGS=['-U__OPTIMIZE__'])
|
||||
tmp_env.Append(CPPFLAGS=["-U__OPTIMIZE__"])
|
||||
sfnt = tmp_env.Object(sfnt)
|
||||
thirdparty_sources += [sfnt]
|
||||
|
||||
|
|
|
|||
|
|
@ -1,5 +1,6 @@
|
|||
def can_build(env, platform):
|
||||
return True
|
||||
|
||||
|
||||
def configure(env):
|
||||
pass
|
||||
|
|
|
|||
|
|
@ -1,7 +1,7 @@
|
|||
#!/usr/bin/env python
|
||||
|
||||
Import('env')
|
||||
Import('env_modules')
|
||||
Import("env")
|
||||
Import("env_modules")
|
||||
|
||||
env_gdnative = env_modules.Clone()
|
||||
env_gdnative.add_source_files(env.modules_sources, "gdnative.cpp")
|
||||
|
|
@ -12,9 +12,9 @@ env_gdnative.add_source_files(env.modules_sources, "nativescript/*.cpp")
|
|||
env_gdnative.add_source_files(env.modules_sources, "gdnative_library_singleton_editor.cpp")
|
||||
env_gdnative.add_source_files(env.modules_sources, "gdnative_library_editor_plugin.cpp")
|
||||
|
||||
env_gdnative.Prepend(CPPPATH=['#modules/gdnative/include/'])
|
||||
env_gdnative.Prepend(CPPPATH=["#modules/gdnative/include/"])
|
||||
|
||||
Export('env_gdnative')
|
||||
Export("env_gdnative")
|
||||
|
||||
SConscript("net/SCsub")
|
||||
SConscript("arvr/SCsub")
|
||||
|
|
@ -25,8 +25,11 @@ SConscript("videodecoder/SCsub")
|
|||
from platform_methods import run_in_subprocess
|
||||
import gdnative_builders
|
||||
|
||||
_, gensource = env_gdnative.CommandNoCache(['include/gdnative_api_struct.gen.h', 'gdnative_api_struct.gen.cpp'],
|
||||
'gdnative_api.json', run_in_subprocess(gdnative_builders.build_gdnative_api_struct))
|
||||
_, gensource = env_gdnative.CommandNoCache(
|
||||
["include/gdnative_api_struct.gen.h", "gdnative_api_struct.gen.cpp"],
|
||||
"gdnative_api.json",
|
||||
run_in_subprocess(gdnative_builders.build_gdnative_api_struct),
|
||||
)
|
||||
env_gdnative.add_source_files(env.modules_sources, [gensource])
|
||||
|
||||
env.use_ptrcall = True
|
||||
|
|
|
|||
|
|
@ -1,6 +1,6 @@
|
|||
#!/usr/bin/env python
|
||||
|
||||
Import('env')
|
||||
Import('env_gdnative')
|
||||
Import("env")
|
||||
Import("env_gdnative")
|
||||
|
||||
env_gdnative.add_source_files(env.modules_sources, '*.cpp')
|
||||
env_gdnative.add_source_files(env.modules_sources, "*.cpp")
|
||||
|
|
|
|||
|
|
@ -1,5 +1,6 @@
|
|||
def can_build(env, platform):
|
||||
return True
|
||||
|
||||
|
||||
def configure(env):
|
||||
pass
|
||||
|
|
|
|||
|
|
@ -1,9 +1,11 @@
|
|||
def can_build(env, platform):
|
||||
return True
|
||||
|
||||
|
||||
def configure(env):
|
||||
env.use_ptrcall = True
|
||||
|
||||
|
||||
def get_doc_classes():
|
||||
return [
|
||||
"@NativeScript",
|
||||
|
|
@ -20,5 +22,6 @@ def get_doc_classes():
|
|||
"WebRTCDataChannelGDNative",
|
||||
]
|
||||
|
||||
|
||||
def get_doc_path():
|
||||
return "doc_classes"
|
||||
|
|
|
|||
|
|
@ -8,209 +8,249 @@ from platform_methods import subprocess_main
|
|||
|
||||
|
||||
def _spaced(e):
|
||||
return e if e[-1] == '*' else e + ' '
|
||||
return e if e[-1] == "*" else e + " "
|
||||
|
||||
|
||||
def _build_gdnative_api_struct_header(api):
|
||||
out = [
|
||||
'/* THIS FILE IS GENERATED DO NOT EDIT */',
|
||||
'#ifndef GODOT_GDNATIVE_API_STRUCT_H',
|
||||
'#define GODOT_GDNATIVE_API_STRUCT_H',
|
||||
'',
|
||||
'#include <gdnative/gdnative.h>',
|
||||
'#include <android/godot_android.h>',
|
||||
'#include <arvr/godot_arvr.h>',
|
||||
'#include <nativescript/godot_nativescript.h>',
|
||||
'#include <net/godot_net.h>',
|
||||
'#include <pluginscript/godot_pluginscript.h>',
|
||||
'#include <videodecoder/godot_videodecoder.h>',
|
||||
'',
|
||||
'#ifdef __cplusplus',
|
||||
"/* THIS FILE IS GENERATED DO NOT EDIT */",
|
||||
"#ifndef GODOT_GDNATIVE_API_STRUCT_H",
|
||||
"#define GODOT_GDNATIVE_API_STRUCT_H",
|
||||
"",
|
||||
"#include <gdnative/gdnative.h>",
|
||||
"#include <android/godot_android.h>",
|
||||
"#include <arvr/godot_arvr.h>",
|
||||
"#include <nativescript/godot_nativescript.h>",
|
||||
"#include <net/godot_net.h>",
|
||||
"#include <pluginscript/godot_pluginscript.h>",
|
||||
"#include <videodecoder/godot_videodecoder.h>",
|
||||
"",
|
||||
"#ifdef __cplusplus",
|
||||
'extern "C" {',
|
||||
'#endif',
|
||||
'',
|
||||
'enum GDNATIVE_API_TYPES {',
|
||||
'\tGDNATIVE_' + api['core']['type'] + ','
|
||||
"#endif",
|
||||
"",
|
||||
"enum GDNATIVE_API_TYPES {",
|
||||
"\tGDNATIVE_" + api["core"]["type"] + ",",
|
||||
]
|
||||
|
||||
for ext in api['extensions']:
|
||||
out += ['\tGDNATIVE_EXT_' + ext['type'] + ',']
|
||||
for ext in api["extensions"]:
|
||||
out += ["\tGDNATIVE_EXT_" + ext["type"] + ","]
|
||||
|
||||
out += ['};', '']
|
||||
out += ["};", ""]
|
||||
|
||||
def generate_extension_struct(name, ext, include_version=True):
|
||||
ret_val = []
|
||||
if ext['next']:
|
||||
ret_val += generate_extension_struct(name, ext['next'])
|
||||
if ext["next"]:
|
||||
ret_val += generate_extension_struct(name, ext["next"])
|
||||
|
||||
ret_val += [
|
||||
'typedef struct godot_gdnative_ext_' + name + ('' if not include_version else ('_{0}_{1}'.format(ext['version']['major'], ext['version']['minor']))) + '_api_struct {',
|
||||
'\tunsigned int type;',
|
||||
'\tgodot_gdnative_api_version version;',
|
||||
'\tconst godot_gdnative_api_struct *next;'
|
||||
"typedef struct godot_gdnative_ext_"
|
||||
+ name
|
||||
+ ("" if not include_version else ("_{0}_{1}".format(ext["version"]["major"], ext["version"]["minor"])))
|
||||
+ "_api_struct {",
|
||||
"\tunsigned int type;",
|
||||
"\tgodot_gdnative_api_version version;",
|
||||
"\tconst godot_gdnative_api_struct *next;",
|
||||
]
|
||||
|
||||
for funcdef in ext['api']:
|
||||
args = ', '.join(['%s%s' % (_spaced(t), n) for t, n in funcdef['arguments']])
|
||||
ret_val.append('\t%s(*%s)(%s);' % (_spaced(funcdef['return_type']), funcdef['name'], args))
|
||||
for funcdef in ext["api"]:
|
||||
args = ", ".join(["%s%s" % (_spaced(t), n) for t, n in funcdef["arguments"]])
|
||||
ret_val.append("\t%s(*%s)(%s);" % (_spaced(funcdef["return_type"]), funcdef["name"], args))
|
||||
|
||||
ret_val += ['} godot_gdnative_ext_' + name + ('' if not include_version else ('_{0}_{1}'.format(ext['version']['major'], ext['version']['minor']))) + '_api_struct;', '']
|
||||
ret_val += [
|
||||
"} godot_gdnative_ext_"
|
||||
+ name
|
||||
+ ("" if not include_version else ("_{0}_{1}".format(ext["version"]["major"], ext["version"]["minor"])))
|
||||
+ "_api_struct;",
|
||||
"",
|
||||
]
|
||||
|
||||
return ret_val
|
||||
|
||||
|
||||
def generate_core_extension_struct(core):
|
||||
ret_val = []
|
||||
if core['next']:
|
||||
ret_val += generate_core_extension_struct(core['next'])
|
||||
if core["next"]:
|
||||
ret_val += generate_core_extension_struct(core["next"])
|
||||
|
||||
ret_val += [
|
||||
'typedef struct godot_gdnative_core_' + ('{0}_{1}'.format(core['version']['major'], core['version']['minor'])) + '_api_struct {',
|
||||
'\tunsigned int type;',
|
||||
'\tgodot_gdnative_api_version version;',
|
||||
'\tconst godot_gdnative_api_struct *next;',
|
||||
"typedef struct godot_gdnative_core_"
|
||||
+ ("{0}_{1}".format(core["version"]["major"], core["version"]["minor"]))
|
||||
+ "_api_struct {",
|
||||
"\tunsigned int type;",
|
||||
"\tgodot_gdnative_api_version version;",
|
||||
"\tconst godot_gdnative_api_struct *next;",
|
||||
]
|
||||
|
||||
for funcdef in core['api']:
|
||||
args = ', '.join(['%s%s' % (_spaced(t), n) for t, n in funcdef['arguments']])
|
||||
ret_val.append('\t%s(*%s)(%s);' % (_spaced(funcdef['return_type']), funcdef['name'], args))
|
||||
for funcdef in core["api"]:
|
||||
args = ", ".join(["%s%s" % (_spaced(t), n) for t, n in funcdef["arguments"]])
|
||||
ret_val.append("\t%s(*%s)(%s);" % (_spaced(funcdef["return_type"]), funcdef["name"], args))
|
||||
|
||||
ret_val += ['} godot_gdnative_core_' + '{0}_{1}'.format(core['version']['major'], core['version']['minor']) + '_api_struct;', '']
|
||||
ret_val += [
|
||||
"} godot_gdnative_core_"
|
||||
+ "{0}_{1}".format(core["version"]["major"], core["version"]["minor"])
|
||||
+ "_api_struct;",
|
||||
"",
|
||||
]
|
||||
|
||||
return ret_val
|
||||
|
||||
|
||||
for ext in api['extensions']:
|
||||
name = ext['name']
|
||||
for ext in api["extensions"]:
|
||||
name = ext["name"]
|
||||
out += generate_extension_struct(name, ext, False)
|
||||
|
||||
if api['core']['next']:
|
||||
out += generate_core_extension_struct(api['core']['next'])
|
||||
if api["core"]["next"]:
|
||||
out += generate_core_extension_struct(api["core"]["next"])
|
||||
|
||||
out += [
|
||||
'typedef struct godot_gdnative_core_api_struct {',
|
||||
'\tunsigned int type;',
|
||||
'\tgodot_gdnative_api_version version;',
|
||||
'\tconst godot_gdnative_api_struct *next;',
|
||||
'\tunsigned int num_extensions;',
|
||||
'\tconst godot_gdnative_api_struct **extensions;',
|
||||
"typedef struct godot_gdnative_core_api_struct {",
|
||||
"\tunsigned int type;",
|
||||
"\tgodot_gdnative_api_version version;",
|
||||
"\tconst godot_gdnative_api_struct *next;",
|
||||
"\tunsigned int num_extensions;",
|
||||
"\tconst godot_gdnative_api_struct **extensions;",
|
||||
]
|
||||
|
||||
for funcdef in api['core']['api']:
|
||||
args = ', '.join(['%s%s' % (_spaced(t), n) for t, n in funcdef['arguments']])
|
||||
out.append('\t%s(*%s)(%s);' % (_spaced(funcdef['return_type']), funcdef['name'], args))
|
||||
for funcdef in api["core"]["api"]:
|
||||
args = ", ".join(["%s%s" % (_spaced(t), n) for t, n in funcdef["arguments"]])
|
||||
out.append("\t%s(*%s)(%s);" % (_spaced(funcdef["return_type"]), funcdef["name"], args))
|
||||
|
||||
out += [
|
||||
'} godot_gdnative_core_api_struct;',
|
||||
'',
|
||||
'#ifdef __cplusplus',
|
||||
'}',
|
||||
'#endif',
|
||||
'',
|
||||
'#endif // GODOT_GDNATIVE_API_STRUCT_H',
|
||||
''
|
||||
"} godot_gdnative_core_api_struct;",
|
||||
"",
|
||||
"#ifdef __cplusplus",
|
||||
"}",
|
||||
"#endif",
|
||||
"",
|
||||
"#endif // GODOT_GDNATIVE_API_STRUCT_H",
|
||||
"",
|
||||
]
|
||||
return '\n'.join(out)
|
||||
return "\n".join(out)
|
||||
|
||||
|
||||
def _build_gdnative_api_struct_source(api):
|
||||
out = [
|
||||
'/* THIS FILE IS GENERATED DO NOT EDIT */',
|
||||
'',
|
||||
'#include <gdnative_api_struct.gen.h>',
|
||||
''
|
||||
]
|
||||
out = ["/* THIS FILE IS GENERATED DO NOT EDIT */", "", "#include <gdnative_api_struct.gen.h>", ""]
|
||||
|
||||
def get_extension_struct_name(name, ext, include_version=True):
|
||||
return 'godot_gdnative_ext_' + name + ('' if not include_version else ('_{0}_{1}'.format(ext['version']['major'], ext['version']['minor']))) + '_api_struct'
|
||||
return (
|
||||
"godot_gdnative_ext_"
|
||||
+ name
|
||||
+ ("" if not include_version else ("_{0}_{1}".format(ext["version"]["major"], ext["version"]["minor"])))
|
||||
+ "_api_struct"
|
||||
)
|
||||
|
||||
def get_extension_struct_instance_name(name, ext, include_version=True):
|
||||
return 'api_extension_' + name + ('' if not include_version else ('_{0}_{1}'.format(ext['version']['major'], ext['version']['minor']))) + '_struct'
|
||||
return (
|
||||
"api_extension_"
|
||||
+ name
|
||||
+ ("" if not include_version else ("_{0}_{1}".format(ext["version"]["major"], ext["version"]["minor"])))
|
||||
+ "_struct"
|
||||
)
|
||||
|
||||
def get_extension_struct_definition(name, ext, include_version=True):
|
||||
|
||||
ret_val = []
|
||||
|
||||
if ext['next']:
|
||||
ret_val += get_extension_struct_definition(name, ext['next'])
|
||||
if ext["next"]:
|
||||
ret_val += get_extension_struct_definition(name, ext["next"])
|
||||
|
||||
ret_val += [
|
||||
'extern const ' + get_extension_struct_name(name, ext, include_version) + ' ' + get_extension_struct_instance_name(name, ext, include_version) + ' = {',
|
||||
'\tGDNATIVE_EXT_' + ext['type'] + ',',
|
||||
'\t{' + str(ext['version']['major']) + ', ' + str(ext['version']['minor']) + '},',
|
||||
'\t' + ('NULL' if not ext['next'] else ('(const godot_gdnative_api_struct *)&' + get_extension_struct_instance_name(name, ext['next']))) + ','
|
||||
"extern const "
|
||||
+ get_extension_struct_name(name, ext, include_version)
|
||||
+ " "
|
||||
+ get_extension_struct_instance_name(name, ext, include_version)
|
||||
+ " = {",
|
||||
"\tGDNATIVE_EXT_" + ext["type"] + ",",
|
||||
"\t{" + str(ext["version"]["major"]) + ", " + str(ext["version"]["minor"]) + "},",
|
||||
"\t"
|
||||
+ (
|
||||
"NULL"
|
||||
if not ext["next"]
|
||||
else ("(const godot_gdnative_api_struct *)&" + get_extension_struct_instance_name(name, ext["next"]))
|
||||
)
|
||||
+ ",",
|
||||
]
|
||||
|
||||
for funcdef in ext['api']:
|
||||
ret_val.append('\t%s,' % funcdef['name'])
|
||||
for funcdef in ext["api"]:
|
||||
ret_val.append("\t%s," % funcdef["name"])
|
||||
|
||||
ret_val += ['};\n']
|
||||
ret_val += ["};\n"]
|
||||
|
||||
return ret_val
|
||||
|
||||
|
||||
def get_core_struct_definition(core):
|
||||
ret_val = []
|
||||
|
||||
if core['next']:
|
||||
ret_val += get_core_struct_definition(core['next'])
|
||||
if core["next"]:
|
||||
ret_val += get_core_struct_definition(core["next"])
|
||||
|
||||
ret_val += [
|
||||
'extern const godot_gdnative_core_' + ('{0}_{1}_api_struct api_{0}_{1}'.format(core['version']['major'], core['version']['minor'])) + ' = {',
|
||||
'\tGDNATIVE_' + core['type'] + ',',
|
||||
'\t{' + str(core['version']['major']) + ', ' + str(core['version']['minor']) + '},',
|
||||
'\t' + ('NULL' if not core['next'] else ('(const godot_gdnative_api_struct *)& api_{0}_{1}'.format(core['next']['version']['major'], core['next']['version']['minor']))) + ','
|
||||
"extern const godot_gdnative_core_"
|
||||
+ ("{0}_{1}_api_struct api_{0}_{1}".format(core["version"]["major"], core["version"]["minor"]))
|
||||
+ " = {",
|
||||
"\tGDNATIVE_" + core["type"] + ",",
|
||||
"\t{" + str(core["version"]["major"]) + ", " + str(core["version"]["minor"]) + "},",
|
||||
"\t"
|
||||
+ (
|
||||
"NULL"
|
||||
if not core["next"]
|
||||
else (
|
||||
"(const godot_gdnative_api_struct *)& api_{0}_{1}".format(
|
||||
core["next"]["version"]["major"], core["next"]["version"]["minor"]
|
||||
)
|
||||
)
|
||||
)
|
||||
+ ",",
|
||||
]
|
||||
|
||||
for funcdef in core['api']:
|
||||
ret_val.append('\t%s,' % funcdef['name'])
|
||||
for funcdef in core["api"]:
|
||||
ret_val.append("\t%s," % funcdef["name"])
|
||||
|
||||
ret_val += ['};\n']
|
||||
ret_val += ["};\n"]
|
||||
|
||||
return ret_val
|
||||
|
||||
for ext in api['extensions']:
|
||||
name = ext['name']
|
||||
for ext in api["extensions"]:
|
||||
name = ext["name"]
|
||||
out += get_extension_struct_definition(name, ext, False)
|
||||
|
||||
out += ['', 'const godot_gdnative_api_struct *gdnative_extensions_pointers[] = {']
|
||||
out += ["", "const godot_gdnative_api_struct *gdnative_extensions_pointers[] = {"]
|
||||
|
||||
for ext in api['extensions']:
|
||||
name = ext['name']
|
||||
out += ['\t(godot_gdnative_api_struct *)&api_extension_' + name + '_struct,']
|
||||
for ext in api["extensions"]:
|
||||
name = ext["name"]
|
||||
out += ["\t(godot_gdnative_api_struct *)&api_extension_" + name + "_struct,"]
|
||||
|
||||
out += ['};\n']
|
||||
out += ["};\n"]
|
||||
|
||||
if api['core']['next']:
|
||||
out += get_core_struct_definition(api['core']['next'])
|
||||
if api["core"]["next"]:
|
||||
out += get_core_struct_definition(api["core"]["next"])
|
||||
|
||||
out += [
|
||||
'extern const godot_gdnative_core_api_struct api_struct = {',
|
||||
'\tGDNATIVE_' + api['core']['type'] + ',',
|
||||
'\t{' + str(api['core']['version']['major']) + ', ' + str(api['core']['version']['minor']) + '},',
|
||||
'\t(const godot_gdnative_api_struct *)&api_1_1,',
|
||||
'\t' + str(len(api['extensions'])) + ',',
|
||||
'\tgdnative_extensions_pointers,',
|
||||
"extern const godot_gdnative_core_api_struct api_struct = {",
|
||||
"\tGDNATIVE_" + api["core"]["type"] + ",",
|
||||
"\t{" + str(api["core"]["version"]["major"]) + ", " + str(api["core"]["version"]["minor"]) + "},",
|
||||
"\t(const godot_gdnative_api_struct *)&api_1_1,",
|
||||
"\t" + str(len(api["extensions"])) + ",",
|
||||
"\tgdnative_extensions_pointers,",
|
||||
]
|
||||
|
||||
for funcdef in api['core']['api']:
|
||||
out.append('\t%s,' % funcdef['name'])
|
||||
out.append('};\n')
|
||||
for funcdef in api["core"]["api"]:
|
||||
out.append("\t%s," % funcdef["name"])
|
||||
out.append("};\n")
|
||||
|
||||
return '\n'.join(out)
|
||||
return "\n".join(out)
|
||||
|
||||
|
||||
def build_gdnative_api_struct(target, source, env):
|
||||
|
||||
with open(source[0], 'r') as fd:
|
||||
with open(source[0], "r") as fd:
|
||||
api = json.load(fd)
|
||||
|
||||
header, source = target
|
||||
with open(header, 'w') as fd:
|
||||
with open(header, "w") as fd:
|
||||
fd.write(_build_gdnative_api_struct_header(api))
|
||||
with open(source, 'w') as fd:
|
||||
with open(source, "w") as fd:
|
||||
fd.write(_build_gdnative_api_struct_source(api))
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
if __name__ == "__main__":
|
||||
subprocess_main(globals())
|
||||
|
|
|
|||
|
|
@ -1,9 +1,9 @@
|
|||
#!/usr/bin/env python
|
||||
|
||||
Import('env')
|
||||
Import('env_gdnative')
|
||||
Import("env")
|
||||
Import("env_gdnative")
|
||||
|
||||
env_gdnative.add_source_files(env.modules_sources, '*.cpp')
|
||||
env_gdnative.add_source_files(env.modules_sources, "*.cpp")
|
||||
|
||||
if "platform" in env and env["platform"] in ["linuxbsd", "iphone"]:
|
||||
env.Append(LINKFLAGS=["-rdynamic"])
|
||||
|
|
|
|||
|
|
@ -1,13 +1,12 @@
|
|||
#!/usr/bin/env python
|
||||
|
||||
Import('env')
|
||||
Import('env_gdnative')
|
||||
Import("env")
|
||||
Import("env_gdnative")
|
||||
|
||||
env_net = env_gdnative.Clone()
|
||||
|
||||
has_webrtc = env_net["module_webrtc_enabled"]
|
||||
if has_webrtc:
|
||||
env_net.Append(CPPDEFINES=['WEBRTC_GDNATIVE_ENABLED'])
|
||||
|
||||
env_net.add_source_files(env.modules_sources, '*.cpp')
|
||||
env_net.Append(CPPDEFINES=["WEBRTC_GDNATIVE_ENABLED"])
|
||||
|
||||
env_net.add_source_files(env.modules_sources, "*.cpp")
|
||||
|
|
|
|||
|
|
@ -1,6 +1,6 @@
|
|||
#!/usr/bin/env python
|
||||
|
||||
Import('env')
|
||||
Import('env_gdnative')
|
||||
Import("env")
|
||||
Import("env_gdnative")
|
||||
|
||||
env_gdnative.add_source_files(env.modules_sources, '*.cpp')
|
||||
env_gdnative.add_source_files(env.modules_sources, "*.cpp")
|
||||
|
|
|
|||
|
|
@ -1,9 +1,9 @@
|
|||
#!/usr/bin/env python
|
||||
|
||||
Import('env')
|
||||
Import('env_modules')
|
||||
Import("env")
|
||||
Import("env_modules")
|
||||
|
||||
env_vsdecoder_gdnative = env_modules.Clone()
|
||||
|
||||
env_vsdecoder_gdnative.Prepend(CPPPATH=['#modules/gdnative/include/'])
|
||||
env_vsdecoder_gdnative.add_source_files(env.modules_sources, '*.cpp')
|
||||
env_vsdecoder_gdnative.Prepend(CPPPATH=["#modules/gdnative/include/"])
|
||||
env_vsdecoder_gdnative.add_source_files(env.modules_sources, "*.cpp")
|
||||
|
|
|
|||
|
|
@ -1,12 +1,12 @@
|
|||
#!/usr/bin/env python
|
||||
|
||||
Import('env')
|
||||
Import('env_modules')
|
||||
Import("env")
|
||||
Import("env_modules")
|
||||
|
||||
env_navigation = env_modules.Clone()
|
||||
|
||||
# Recast Thirdparty source files
|
||||
if env['builtin_recast']:
|
||||
if env["builtin_recast"]:
|
||||
thirdparty_dir = "#thirdparty/recastnavigation/Recast/"
|
||||
thirdparty_sources = [
|
||||
"Source/Recast.cpp",
|
||||
|
|
@ -31,7 +31,7 @@ if env['builtin_recast']:
|
|||
|
||||
|
||||
# RVO Thirdparty source files
|
||||
if env['builtin_rvo2']:
|
||||
if env["builtin_rvo2"]:
|
||||
thirdparty_dir = "#thirdparty/rvo2"
|
||||
thirdparty_sources = [
|
||||
"/src/Agent.cpp",
|
||||
|
|
|
|||
|
|
@ -1,5 +1,6 @@
|
|||
def can_build(env, platform):
|
||||
return True
|
||||
|
||||
|
||||
def configure(env):
|
||||
pass
|
||||
|
|
|
|||
|
|
@ -1,19 +1,19 @@
|
|||
#!/usr/bin/env python
|
||||
|
||||
Import('env')
|
||||
Import('env_modules')
|
||||
Import("env")
|
||||
Import("env_modules")
|
||||
|
||||
env_gdscript = env_modules.Clone()
|
||||
|
||||
env_gdscript.add_source_files(env.modules_sources, "*.cpp")
|
||||
|
||||
if env['tools']:
|
||||
if env["tools"]:
|
||||
env_gdscript.add_source_files(env.modules_sources, "./editor/*.cpp")
|
||||
|
||||
# Those two modules are required for the language server protocol
|
||||
if env['module_jsonrpc_enabled'] and env['module_websocket_enabled']:
|
||||
if env["module_jsonrpc_enabled"] and env["module_websocket_enabled"]:
|
||||
env_gdscript.add_source_files(env.modules_sources, "./language_server/*.cpp")
|
||||
else:
|
||||
# Using a define in the disabled case, to avoid having an extra define
|
||||
# in regular builds where all modules are enabled.
|
||||
env_gdscript.Append(CPPDEFINES=['GDSCRIPT_NO_LSP'])
|
||||
env_gdscript.Append(CPPDEFINES=["GDSCRIPT_NO_LSP"])
|
||||
|
|
|
|||
|
|
@ -1,9 +1,11 @@
|
|||
def can_build(env, platform):
|
||||
return True
|
||||
|
||||
|
||||
def configure(env):
|
||||
pass
|
||||
|
||||
|
||||
def get_doc_classes():
|
||||
return [
|
||||
"@GDScript",
|
||||
|
|
@ -12,5 +14,6 @@ def get_doc_classes():
|
|||
"GDScriptNativeClass",
|
||||
]
|
||||
|
||||
|
||||
def get_doc_path():
|
||||
return "doc_classes"
|
||||
|
|
|
|||
|
|
@ -1,12 +1,12 @@
|
|||
#!/usr/bin/env python
|
||||
|
||||
Import('env')
|
||||
Import('env_modules')
|
||||
Import("env")
|
||||
Import("env_modules")
|
||||
|
||||
env_glslang = env_modules.Clone()
|
||||
|
||||
# Thirdparty source files
|
||||
if env['builtin_glslang']:
|
||||
if env["builtin_glslang"]:
|
||||
thirdparty_dir = "#thirdparty/glslang/"
|
||||
thirdparty_sources = [
|
||||
"glslang/MachineIndependent/RemoveTree.cpp",
|
||||
|
|
@ -48,10 +48,10 @@ if env['builtin_glslang']:
|
|||
"SPIRV/doc.cpp",
|
||||
"SPIRV/SPVRemapper.cpp",
|
||||
"SPIRV/SpvPostProcess.cpp",
|
||||
"SPIRV/Logger.cpp"
|
||||
"SPIRV/Logger.cpp",
|
||||
]
|
||||
|
||||
if (env["platform"]=="windows"):
|
||||
if env["platform"] == "windows":
|
||||
thirdparty_sources.append("glslang/OSDependent/Windows/ossource.cpp")
|
||||
else:
|
||||
thirdparty_sources.append("glslang/OSDependent/Unix/ossource.cpp")
|
||||
|
|
@ -60,7 +60,7 @@ if env['builtin_glslang']:
|
|||
|
||||
# Treat glslang headers as system headers to avoid raising warnings. Not supported on MSVC.
|
||||
if not env.msvc:
|
||||
env_glslang.Append(CPPFLAGS=['-isystem', Dir(thirdparty_dir).path])
|
||||
env_glslang.Append(CPPFLAGS=["-isystem", Dir(thirdparty_dir).path])
|
||||
else:
|
||||
env_glslang.Prepend(CPPPATH=[thirdparty_dir])
|
||||
|
||||
|
|
|
|||
|
|
@ -1,5 +1,6 @@
|
|||
def can_build(env, platform):
|
||||
return True
|
||||
|
||||
|
||||
def configure(env):
|
||||
pass
|
||||
|
|
|
|||
|
|
@ -1,7 +1,7 @@
|
|||
#!/usr/bin/env python
|
||||
|
||||
Import('env')
|
||||
Import('env_modules')
|
||||
Import("env")
|
||||
Import("env_modules")
|
||||
|
||||
env_gridmap = env_modules.Clone()
|
||||
|
||||
|
|
|
|||
|
|
@ -1,13 +1,16 @@
|
|||
def can_build(env, platform):
|
||||
return True
|
||||
|
||||
|
||||
def configure(env):
|
||||
pass
|
||||
|
||||
|
||||
def get_doc_classes():
|
||||
return [
|
||||
"GridMap",
|
||||
]
|
||||
|
||||
|
||||
def get_doc_path():
|
||||
return "doc_classes"
|
||||
|
|
|
|||
|
|
@ -1,7 +1,7 @@
|
|||
#!/usr/bin/env python
|
||||
|
||||
Import('env')
|
||||
Import('env_modules')
|
||||
Import("env")
|
||||
Import("env_modules")
|
||||
|
||||
env_hdr = env_modules.Clone()
|
||||
|
||||
|
|
|
|||
|
|
@ -1,5 +1,6 @@
|
|||
def can_build(env, platform):
|
||||
return True
|
||||
|
||||
|
||||
def configure(env):
|
||||
pass
|
||||
|
|
|
|||
|
|
@ -1,7 +1,7 @@
|
|||
#!/usr/bin/env python
|
||||
|
||||
Import('env')
|
||||
Import('env_modules')
|
||||
Import("env")
|
||||
Import("env_modules")
|
||||
|
||||
env_jpg = env_modules.Clone()
|
||||
|
||||
|
|
|
|||
|
|
@ -1,5 +1,6 @@
|
|||
def can_build(env, platform):
|
||||
return True
|
||||
|
||||
|
||||
def configure(env):
|
||||
pass
|
||||
|
|
|
|||
|
|
@ -1,7 +1,7 @@
|
|||
#!/usr/bin/env python
|
||||
|
||||
Import('env')
|
||||
Import('env_modules')
|
||||
Import("env")
|
||||
Import("env_modules")
|
||||
|
||||
env_jsonrpc = env_modules.Clone()
|
||||
env_jsonrpc.add_source_files(env.modules_sources, "*.cpp")
|
||||
|
|
|
|||
|
|
@ -1,5 +1,6 @@
|
|||
def can_build(env, platform):
|
||||
return True
|
||||
|
||||
|
||||
def configure(env):
|
||||
pass
|
||||
|
|
|
|||
|
|
@ -1,11 +1,11 @@
|
|||
#!/usr/bin/env python
|
||||
|
||||
Import('env')
|
||||
Import('env_modules')
|
||||
Import("env")
|
||||
Import("env_modules")
|
||||
|
||||
env_mbed_tls = env_modules.Clone()
|
||||
|
||||
if env['builtin_mbedtls']:
|
||||
if env["builtin_mbedtls"]:
|
||||
# Thirdparty source files
|
||||
thirdparty_sources = [
|
||||
"aes.c",
|
||||
|
|
@ -86,7 +86,7 @@ if env['builtin_mbedtls']:
|
|||
"x509_csr.c",
|
||||
"x509write_crt.c",
|
||||
"x509write_csr.c",
|
||||
"xtea.c"
|
||||
"xtea.c",
|
||||
]
|
||||
|
||||
thirdparty_dir = "#thirdparty/mbedtls/library/"
|
||||
|
|
|
|||
|
|
@ -1,5 +1,6 @@
|
|||
def can_build(env, platform):
|
||||
return True
|
||||
|
||||
|
||||
def configure(env):
|
||||
pass
|
||||
|
|
|
|||
|
|
@ -1,8 +1,8 @@
|
|||
#!/usr/bin/env python
|
||||
|
||||
Import('env')
|
||||
Import('env_modules')
|
||||
Import("env")
|
||||
Import("env_modules")
|
||||
|
||||
env_mobile_vr = env_modules.Clone()
|
||||
|
||||
env_mobile_vr.add_source_files(env.modules_sources, '*.cpp')
|
||||
env_mobile_vr.add_source_files(env.modules_sources, "*.cpp")
|
||||
|
|
|
|||
Some files were not shown because too many files have changed in this diff Show More
Loading…
Reference in New Issue