2024-05-21 21:14:59 +08:00
|
|
|
import contextlib
|
|
|
|
import glob
|
2014-02-10 09:10:30 +08:00
|
|
|
import os
|
2018-03-18 06:23:55 +08:00
|
|
|
import re
|
|
|
|
import subprocess
|
2024-05-21 21:14:59 +08:00
|
|
|
import sys
|
2020-05-28 23:17:14 +08:00
|
|
|
from collections import OrderedDict
|
2024-04-27 01:35:07 +08:00
|
|
|
from enum import Enum
|
2024-05-21 21:14:59 +08:00
|
|
|
from io import StringIO, TextIOWrapper
|
2023-05-17 23:22:26 +08:00
|
|
|
from pathlib import Path
|
2024-08-01 03:15:56 +08:00
|
|
|
from typing import Generator, List, Optional, Union
|
2024-05-03 22:44:57 +08:00
|
|
|
|
2023-05-17 23:22:26 +08:00
|
|
|
# Get the "Godot" folder name ahead of time
|
|
|
|
base_folder_path = str(os.path.abspath(Path(__file__).parent)) + "/"
|
|
|
|
base_folder_only = os.path.basename(os.path.normpath(base_folder_path))
|
|
|
|
# Listing all the folders we have converted
|
|
|
|
# for SCU in scu_builders.py
|
|
|
|
_scu_folders = set()
|
2024-04-27 01:35:07 +08:00
|
|
|
# Colors are disabled in non-TTY environments such as pipes. This means
|
|
|
|
# that if output is redirected to a file, it won't contain color codes.
|
|
|
|
# Colors are always enabled on continuous integration.
|
|
|
|
_colorize = bool(sys.stdout.isatty() or os.environ.get("CI"))
|
2016-10-31 02:05:14 +08:00
|
|
|
|
2023-05-17 23:22:26 +08:00
|
|
|
|
|
|
|
def set_scu_folders(scu_folders):
|
|
|
|
global _scu_folders
|
|
|
|
_scu_folders = scu_folders
|
|
|
|
|
|
|
|
|
2024-04-27 01:35:07 +08:00
|
|
|
class ANSI(Enum):
|
|
|
|
"""
|
|
|
|
Enum class for adding ansi colorcodes directly into strings.
|
|
|
|
Automatically converts values to strings representing their
|
|
|
|
internal value, or an empty string in a non-colorized scope.
|
|
|
|
"""
|
|
|
|
|
|
|
|
RESET = "\x1b[0m"
|
|
|
|
|
2024-04-30 00:56:21 +08:00
|
|
|
BOLD = "\x1b[1m"
|
|
|
|
ITALIC = "\x1b[3m"
|
|
|
|
UNDERLINE = "\x1b[4m"
|
|
|
|
STRIKETHROUGH = "\x1b[9m"
|
|
|
|
REGULAR = "\x1b[22;23;24;29m"
|
|
|
|
|
|
|
|
BLACK = "\x1b[30m"
|
|
|
|
RED = "\x1b[31m"
|
|
|
|
GREEN = "\x1b[32m"
|
|
|
|
YELLOW = "\x1b[33m"
|
|
|
|
BLUE = "\x1b[34m"
|
|
|
|
MAGENTA = "\x1b[35m"
|
|
|
|
CYAN = "\x1b[36m"
|
|
|
|
WHITE = "\x1b[37m"
|
|
|
|
|
|
|
|
PURPLE = "\x1b[38;5;93m"
|
|
|
|
PINK = "\x1b[38;5;206m"
|
|
|
|
ORANGE = "\x1b[38;5;214m"
|
|
|
|
GRAY = "\x1b[38;5;244m"
|
|
|
|
|
|
|
|
def __str__(self) -> str:
|
2024-04-27 01:35:07 +08:00
|
|
|
global _colorize
|
2024-04-30 00:56:21 +08:00
|
|
|
return str(self.value) if _colorize else ""
|
2024-04-27 01:35:07 +08:00
|
|
|
|
|
|
|
|
|
|
|
def print_warning(*values: object) -> None:
|
|
|
|
"""Prints a warning message with formatting."""
|
2024-04-30 00:56:21 +08:00
|
|
|
print(f"{ANSI.YELLOW}{ANSI.BOLD}WARNING:{ANSI.REGULAR}", *values, ANSI.RESET, file=sys.stderr)
|
2024-04-27 01:35:07 +08:00
|
|
|
|
|
|
|
|
|
|
|
def print_error(*values: object) -> None:
|
|
|
|
"""Prints an error message with formatting."""
|
2024-04-30 00:56:21 +08:00
|
|
|
print(f"{ANSI.RED}{ANSI.BOLD}ERROR:{ANSI.REGULAR}", *values, ANSI.RESET, file=sys.stderr)
|
2024-04-27 01:35:07 +08:00
|
|
|
|
|
|
|
|
2023-05-17 23:22:26 +08:00
|
|
|
def add_source_files_orig(self, sources, files, allow_gen=False):
|
2019-07-22 19:57:39 +08:00
|
|
|
# Convert string to list of absolute paths (including expanding wildcard)
|
2020-03-25 21:36:03 +08:00
|
|
|
if isinstance(files, (str, bytes)):
|
2019-07-22 19:57:39 +08:00
|
|
|
# Keep SCons project-absolute path as they are (no wildcard support)
|
2020-03-30 14:28:32 +08:00
|
|
|
if files.startswith("#"):
|
|
|
|
if "*" in files:
|
2024-04-27 01:35:07 +08:00
|
|
|
print_error("Wildcards can't be expanded in SCons project-absolute path: '{}'".format(files))
|
2019-07-22 19:57:39 +08:00
|
|
|
return
|
|
|
|
files = [files]
|
|
|
|
else:
|
2021-10-16 03:59:11 +08:00
|
|
|
# Exclude .gen.cpp files from globbing, to avoid including obsolete ones.
|
|
|
|
# They should instead be added manually.
|
|
|
|
skip_gen_cpp = "*" in files
|
2020-03-30 14:28:32 +08:00
|
|
|
dir_path = self.Dir(".").abspath
|
2019-07-22 19:57:39 +08:00
|
|
|
files = sorted(glob.glob(dir_path + "/" + files))
|
2023-05-17 23:22:26 +08:00
|
|
|
if skip_gen_cpp and not allow_gen:
|
2021-10-16 03:59:11 +08:00
|
|
|
files = [f for f in files if not f.endswith(".gen.cpp")]
|
2019-07-22 19:57:39 +08:00
|
|
|
|
|
|
|
# Add each path as compiled Object following environment (self) configuration
|
|
|
|
for path in files:
|
|
|
|
obj = self.Object(path)
|
|
|
|
if obj in sources:
|
2024-04-27 01:35:07 +08:00
|
|
|
print_warning('Object "{}" already included in environment sources.'.format(obj))
|
2021-10-16 03:59:11 +08:00
|
|
|
continue
|
2019-07-22 19:57:39 +08:00
|
|
|
sources.append(obj)
|
2014-02-10 09:10:30 +08:00
|
|
|
|
|
|
|
|
2023-05-17 23:22:26 +08:00
|
|
|
# The section name is used for checking
|
|
|
|
# the hash table to see whether the folder
|
|
|
|
# is included in the SCU build.
|
|
|
|
# It will be something like "core/math".
|
|
|
|
def _find_scu_section_name(subdir):
|
|
|
|
section_path = os.path.abspath(subdir) + "/"
|
|
|
|
|
|
|
|
folders = []
|
|
|
|
folder = ""
|
|
|
|
|
|
|
|
for i in range(8):
|
|
|
|
folder = os.path.dirname(section_path)
|
|
|
|
folder = os.path.basename(folder)
|
|
|
|
if folder == base_folder_only:
|
|
|
|
break
|
|
|
|
folders += [folder]
|
|
|
|
section_path += "../"
|
|
|
|
section_path = os.path.abspath(section_path) + "/"
|
|
|
|
|
|
|
|
section_name = ""
|
|
|
|
for n in range(len(folders)):
|
|
|
|
# section_name += folders[len(folders) - n - 1] + " "
|
|
|
|
section_name += folders[len(folders) - n - 1]
|
|
|
|
if n != (len(folders) - 1):
|
|
|
|
section_name += "/"
|
|
|
|
|
|
|
|
return section_name
|
|
|
|
|
|
|
|
|
|
|
|
def add_source_files_scu(self, sources, files, allow_gen=False):
|
2023-06-08 02:30:40 +08:00
|
|
|
if self["scu_build"] and isinstance(files, str):
|
2023-05-17 23:22:26 +08:00
|
|
|
if "*." not in files:
|
|
|
|
return False
|
|
|
|
|
|
|
|
# If the files are in a subdirectory, we want to create the scu gen
|
|
|
|
# files inside this subdirectory.
|
|
|
|
subdir = os.path.dirname(files)
|
|
|
|
if subdir != "":
|
|
|
|
subdir += "/"
|
|
|
|
|
|
|
|
section_name = _find_scu_section_name(subdir)
|
|
|
|
# if the section name is in the hash table?
|
|
|
|
# i.e. is it part of the SCU build?
|
|
|
|
global _scu_folders
|
|
|
|
if section_name not in (_scu_folders):
|
|
|
|
return False
|
|
|
|
|
|
|
|
# Add all the gen.cpp files in the SCU directory
|
|
|
|
add_source_files_orig(self, sources, subdir + "scu/scu_*.gen.cpp", True)
|
|
|
|
return True
|
|
|
|
return False
|
|
|
|
|
|
|
|
|
|
|
|
# Either builds the folder using the SCU system,
|
|
|
|
# or reverts to regular build.
|
|
|
|
def add_source_files(self, sources, files, allow_gen=False):
|
|
|
|
if not add_source_files_scu(self, sources, files, allow_gen):
|
|
|
|
# Wraps the original function when scu build is not active.
|
|
|
|
add_source_files_orig(self, sources, files, allow_gen)
|
|
|
|
return False
|
|
|
|
return True
|
|
|
|
|
|
|
|
|
2018-09-28 19:29:52 +08:00
|
|
|
def disable_warnings(self):
|
|
|
|
# 'self' is the environment
|
2024-05-24 21:07:22 +08:00
|
|
|
if self.msvc and not using_clang(self):
|
2018-10-03 19:38:09 +08:00
|
|
|
# We have to remove existing warning level defines before appending /w,
|
|
|
|
# otherwise we get: "warning D9025 : overriding '/W3' with '/w'"
|
2022-09-27 18:35:12 +08:00
|
|
|
self["CCFLAGS"] = [x for x in self["CCFLAGS"] if not (x.startswith("/W") or x.startswith("/w"))]
|
|
|
|
self["CFLAGS"] = [x for x in self["CFLAGS"] if not (x.startswith("/W") or x.startswith("/w"))]
|
|
|
|
self["CXXFLAGS"] = [x for x in self["CXXFLAGS"] if not (x.startswith("/W") or x.startswith("/w"))]
|
|
|
|
self.AppendUnique(CCFLAGS=["/w"])
|
2018-09-28 19:29:52 +08:00
|
|
|
else:
|
2022-09-27 18:35:12 +08:00
|
|
|
self.AppendUnique(CCFLAGS=["-w"])
|
2018-09-28 19:29:52 +08:00
|
|
|
|
|
|
|
|
2021-09-28 17:59:56 +08:00
|
|
|
def force_optimization_on_debug(self):
|
|
|
|
# 'self' is the environment
|
2023-04-11 04:46:03 +08:00
|
|
|
if self["target"] == "template_release":
|
2021-09-28 17:59:56 +08:00
|
|
|
return
|
|
|
|
|
|
|
|
if self.msvc:
|
2022-09-27 18:35:12 +08:00
|
|
|
# We have to remove existing optimization level defines before appending /O2,
|
|
|
|
# otherwise we get: "warning D9025 : overriding '/0d' with '/02'"
|
|
|
|
self["CCFLAGS"] = [x for x in self["CCFLAGS"] if not x.startswith("/O")]
|
|
|
|
self["CFLAGS"] = [x for x in self["CFLAGS"] if not x.startswith("/O")]
|
|
|
|
self["CXXFLAGS"] = [x for x in self["CXXFLAGS"] if not x.startswith("/O")]
|
|
|
|
self.AppendUnique(CCFLAGS=["/O2"])
|
2021-09-28 17:59:56 +08:00
|
|
|
else:
|
2022-09-27 18:35:12 +08:00
|
|
|
self.AppendUnique(CCFLAGS=["-O3"])
|
2021-09-28 17:59:56 +08:00
|
|
|
|
|
|
|
|
2020-03-30 14:28:32 +08:00
|
|
|
def add_module_version_string(self, s):
|
2017-11-20 04:18:01 +08:00
|
|
|
self.module_version_string += "." + s
|
2017-11-02 10:12:28 +08:00
|
|
|
|
2018-03-18 06:23:55 +08:00
|
|
|
|
2022-09-14 17:28:58 +08:00
|
|
|
def get_version_info(module_version_string="", silent=False):
|
2017-11-20 04:26:05 +08:00
|
|
|
build_name = "custom_build"
|
2024-05-21 21:14:59 +08:00
|
|
|
if os.getenv("BUILD_NAME") is not None:
|
2021-07-29 17:19:18 +08:00
|
|
|
build_name = str(os.getenv("BUILD_NAME"))
|
2022-09-14 17:28:58 +08:00
|
|
|
if not silent:
|
|
|
|
print(f"Using custom build name: '{build_name}'.")
|
2016-04-03 02:26:12 +08:00
|
|
|
|
2016-10-31 01:44:57 +08:00
|
|
|
import version
|
2016-04-03 02:26:12 +08:00
|
|
|
|
2022-09-14 17:28:58 +08:00
|
|
|
version_info = {
|
|
|
|
"short_name": str(version.short_name),
|
|
|
|
"name": str(version.name),
|
|
|
|
"major": int(version.major),
|
|
|
|
"minor": int(version.minor),
|
|
|
|
"patch": int(version.patch),
|
|
|
|
"status": str(version.status),
|
|
|
|
"build": str(build_name),
|
|
|
|
"module_config": str(version.module_config) + module_version_string,
|
|
|
|
"website": str(version.website),
|
|
|
|
"docs_branch": str(version.docs),
|
|
|
|
}
|
|
|
|
|
2021-07-29 17:19:18 +08:00
|
|
|
# For dev snapshots (alpha, beta, RC, etc.) we do not commit status change to Git,
|
|
|
|
# so this define provides a way to override it without having to modify the source.
|
2024-05-21 21:14:59 +08:00
|
|
|
if os.getenv("GODOT_VERSION_STATUS") is not None:
|
2022-09-14 17:28:58 +08:00
|
|
|
version_info["status"] = str(os.getenv("GODOT_VERSION_STATUS"))
|
|
|
|
if not silent:
|
2022-09-25 19:26:47 +08:00
|
|
|
print(f"Using version status '{version_info['status']}', overriding the original '{version.status}'.")
|
2017-07-10 16:47:38 +08:00
|
|
|
|
2022-09-14 17:28:58 +08:00
|
|
|
# Parse Git hash if we're in a Git repo.
|
2017-07-10 16:47:38 +08:00
|
|
|
githash = ""
|
2019-02-09 02:17:07 +08:00
|
|
|
gitfolder = ".git"
|
|
|
|
|
|
|
|
if os.path.isfile(".git"):
|
2024-03-25 01:02:56 +08:00
|
|
|
with open(".git", "r", encoding="utf-8") as file:
|
2024-03-11 01:09:48 +08:00
|
|
|
module_folder = file.readline().strip()
|
2019-02-09 02:17:07 +08:00
|
|
|
if module_folder.startswith("gitdir: "):
|
|
|
|
gitfolder = module_folder[8:]
|
|
|
|
|
|
|
|
if os.path.isfile(os.path.join(gitfolder, "HEAD")):
|
2024-03-11 01:09:48 +08:00
|
|
|
with open(os.path.join(gitfolder, "HEAD"), "r", encoding="utf8") as file:
|
|
|
|
head = file.readline().strip()
|
2017-07-10 16:47:38 +08:00
|
|
|
if head.startswith("ref: "):
|
2022-07-25 10:09:54 +08:00
|
|
|
ref = head[5:]
|
2023-01-10 00:36:22 +08:00
|
|
|
# If this directory is a Git worktree instead of a root clone.
|
|
|
|
parts = gitfolder.split("/")
|
|
|
|
if len(parts) > 2 and parts[-2] == "worktrees":
|
|
|
|
gitfolder = "/".join(parts[0:-2])
|
2022-07-25 10:09:54 +08:00
|
|
|
head = os.path.join(gitfolder, ref)
|
|
|
|
packedrefs = os.path.join(gitfolder, "packed-refs")
|
2017-07-10 16:47:38 +08:00
|
|
|
if os.path.isfile(head):
|
2024-03-25 01:02:56 +08:00
|
|
|
with open(head, "r", encoding="utf-8") as file:
|
2024-03-11 01:09:48 +08:00
|
|
|
githash = file.readline().strip()
|
2022-07-25 10:09:54 +08:00
|
|
|
elif os.path.isfile(packedrefs):
|
|
|
|
# Git may pack refs into a single file. This code searches .git/packed-refs file for the current ref's hash.
|
|
|
|
# https://mirrors.edge.kernel.org/pub/software/scm/git/docs/git-pack-refs.html
|
2024-03-25 01:02:56 +08:00
|
|
|
for line in open(packedrefs, "r", encoding="utf-8").read().splitlines():
|
2022-07-25 10:09:54 +08:00
|
|
|
if line.startswith("#"):
|
|
|
|
continue
|
|
|
|
(line_hash, line_ref) = line.split(" ")
|
|
|
|
if ref == line_ref:
|
|
|
|
githash = line_hash
|
|
|
|
break
|
2017-07-10 16:47:38 +08:00
|
|
|
else:
|
|
|
|
githash = head
|
2019-02-09 02:17:07 +08:00
|
|
|
|
2022-09-14 17:28:58 +08:00
|
|
|
version_info["git_hash"] = githash
|
2022-03-12 09:04:14 +08:00
|
|
|
# Fallback to 0 as a timestamp (will be treated as "unknown" in the engine).
|
|
|
|
version_info["git_timestamp"] = 0
|
|
|
|
|
|
|
|
# Get the UNIX timestamp of the build commit.
|
|
|
|
if os.path.exists(".git"):
|
|
|
|
try:
|
|
|
|
version_info["git_timestamp"] = subprocess.check_output(
|
2024-07-09 03:46:23 +08:00
|
|
|
["git", "log", "-1", "--pretty=format:%ct", "--no-show-signature", githash]
|
2022-03-12 09:04:14 +08:00
|
|
|
).decode("utf-8")
|
|
|
|
except (subprocess.CalledProcessError, OSError):
|
|
|
|
# `git` not found in PATH.
|
|
|
|
pass
|
2022-09-14 17:28:58 +08:00
|
|
|
|
|
|
|
return version_info
|
|
|
|
|
|
|
|
|
2014-02-10 09:10:30 +08:00
|
|
|
def parse_cg_file(fname, uniforms, sizes, conditionals):
|
2024-03-25 01:02:56 +08:00
|
|
|
with open(fname, "r", encoding="utf-8") as fs:
|
2024-03-11 01:09:48 +08:00
|
|
|
line = fs.readline()
|
2014-02-10 09:10:30 +08:00
|
|
|
|
2024-03-11 01:09:48 +08:00
|
|
|
while line:
|
|
|
|
if re.match(r"^\s*uniform", line):
|
|
|
|
res = re.match(r"uniform ([\d\w]*) ([\d\w]*)")
|
|
|
|
type = res.groups(1)
|
|
|
|
name = res.groups(2)
|
2014-02-10 09:10:30 +08:00
|
|
|
|
2024-03-11 01:09:48 +08:00
|
|
|
uniforms.append(name)
|
2014-02-10 09:10:30 +08:00
|
|
|
|
2024-03-11 01:09:48 +08:00
|
|
|
if type.find("texobj") != -1:
|
|
|
|
sizes.append(1)
|
2016-10-31 01:44:57 +08:00
|
|
|
else:
|
2024-03-11 01:09:48 +08:00
|
|
|
t = re.match(r"float(\d)x(\d)", type)
|
|
|
|
if t:
|
|
|
|
sizes.append(int(t.groups(1)) * int(t.groups(2)))
|
|
|
|
else:
|
|
|
|
t = re.match(r"float(\d)", type)
|
|
|
|
sizes.append(int(t.groups(1)))
|
2014-02-10 09:10:30 +08:00
|
|
|
|
2024-03-11 01:09:48 +08:00
|
|
|
if line.find("[branch]") != -1:
|
|
|
|
conditionals.append(name)
|
2014-02-10 09:10:30 +08:00
|
|
|
|
2024-03-11 01:09:48 +08:00
|
|
|
line = fs.readline()
|
2018-03-11 01:37:33 +08:00
|
|
|
|
|
|
|
|
2021-02-24 17:05:30 +08:00
|
|
|
def get_cmdline_bool(option, default):
|
|
|
|
"""We use `ARGUMENTS.get()` to check if options were manually overridden on the command line,
|
|
|
|
and SCons' _text2bool helper to convert them to booleans, otherwise they're handled as strings.
|
|
|
|
"""
|
2022-09-29 04:51:40 +08:00
|
|
|
from SCons.Script import ARGUMENTS
|
|
|
|
from SCons.Variables.BoolVariable import _text2bool
|
|
|
|
|
2021-02-24 17:05:30 +08:00
|
|
|
cmdline_val = ARGUMENTS.get(option)
|
|
|
|
if cmdline_val is not None:
|
|
|
|
return _text2bool(cmdline_val)
|
|
|
|
else:
|
|
|
|
return default
|
|
|
|
|
|
|
|
|
2020-10-24 03:28:21 +08:00
|
|
|
def detect_modules(search_path, recursive=False):
|
|
|
|
"""Detects and collects a list of C++ modules at specified path
|
2014-02-10 09:10:30 +08:00
|
|
|
|
2020-10-24 03:28:21 +08:00
|
|
|
`search_path` - a directory path containing modules. The path may point to
|
|
|
|
a single module, which may have other nested modules. A module must have
|
|
|
|
"register_types.h", "SCsub", "config.py" files created to be detected.
|
2020-03-09 00:34:09 +08:00
|
|
|
|
2020-10-24 03:28:21 +08:00
|
|
|
`recursive` - if `True`, then all subdirectories are searched for modules as
|
|
|
|
specified by the `search_path`, otherwise collects all modules under the
|
|
|
|
`search_path` directory. If the `search_path` is a module, it is collected
|
|
|
|
in all cases.
|
2020-03-09 00:34:09 +08:00
|
|
|
|
2020-10-24 03:28:21 +08:00
|
|
|
Returns an `OrderedDict` with module names as keys, and directory paths as
|
|
|
|
values. If a path is relative, then it is a built-in module. If a path is
|
|
|
|
absolute, then it is a custom module collected outside of the engine source.
|
|
|
|
"""
|
|
|
|
modules = OrderedDict()
|
|
|
|
|
|
|
|
def add_module(path):
|
|
|
|
module_name = os.path.basename(path)
|
|
|
|
module_path = path.replace("\\", "/") # win32
|
|
|
|
modules[module_name] = module_path
|
|
|
|
|
|
|
|
def is_engine(path):
|
|
|
|
# Prevent recursively detecting modules in self and other
|
|
|
|
# Godot sources when using `custom_modules` build option.
|
|
|
|
version_path = os.path.join(path, "version.py")
|
|
|
|
if os.path.exists(version_path):
|
2024-06-19 17:20:48 +08:00
|
|
|
with open(version_path, "r", encoding="utf-8") as f:
|
2021-02-12 00:54:35 +08:00
|
|
|
if 'short_name = "godot"' in f.read():
|
2020-10-24 03:28:21 +08:00
|
|
|
return True
|
|
|
|
return False
|
|
|
|
|
|
|
|
def get_files(path):
|
|
|
|
files = glob.glob(os.path.join(path, "*"))
|
|
|
|
# Sort so that `register_module_types` does not change that often,
|
|
|
|
# and plugins are registered in alphabetic order as well.
|
|
|
|
files.sort()
|
|
|
|
return files
|
|
|
|
|
|
|
|
if not recursive:
|
|
|
|
if is_module(search_path):
|
|
|
|
add_module(search_path)
|
|
|
|
for path in get_files(search_path):
|
|
|
|
if is_engine(path):
|
|
|
|
continue
|
|
|
|
if is_module(path):
|
|
|
|
add_module(path)
|
|
|
|
else:
|
|
|
|
to_search = [search_path]
|
|
|
|
while to_search:
|
|
|
|
path = to_search.pop()
|
|
|
|
if is_module(path):
|
|
|
|
add_module(path)
|
|
|
|
for child in get_files(path):
|
|
|
|
if not os.path.isdir(child):
|
|
|
|
continue
|
|
|
|
if is_engine(child):
|
|
|
|
continue
|
|
|
|
to_search.insert(0, child)
|
|
|
|
return modules
|
2020-03-09 00:34:09 +08:00
|
|
|
|
|
|
|
|
|
|
|
def is_module(path):
|
2020-10-24 03:28:21 +08:00
|
|
|
if not os.path.isdir(path):
|
|
|
|
return False
|
|
|
|
must_exist = ["register_types.h", "SCsub", "config.py"]
|
|
|
|
for f in must_exist:
|
|
|
|
if not os.path.exists(os.path.join(path, f)):
|
|
|
|
return False
|
|
|
|
return True
|
2020-03-09 00:34:09 +08:00
|
|
|
|
|
|
|
|
|
|
|
def convert_custom_modules_path(path):
|
|
|
|
if not path:
|
|
|
|
return path
|
2020-07-10 20:57:53 +08:00
|
|
|
path = os.path.realpath(os.path.expanduser(os.path.expandvars(path)))
|
2020-03-09 00:34:09 +08:00
|
|
|
err_msg = "Build option 'custom_modules' must %s"
|
|
|
|
if not os.path.isdir(path):
|
|
|
|
raise ValueError(err_msg % "point to an existing directory.")
|
2020-07-10 20:57:53 +08:00
|
|
|
if path == os.path.realpath("modules"):
|
2020-03-09 00:34:09 +08:00
|
|
|
raise ValueError(err_msg % "be a directory other than built-in `modules` directory.")
|
2020-07-10 20:57:53 +08:00
|
|
|
return path
|
2014-02-10 09:10:30 +08:00
|
|
|
|
|
|
|
|
|
|
|
def disable_module(self):
|
2016-10-31 01:44:57 +08:00
|
|
|
self.disabled_modules.append(self.current_module)
|
2016-01-25 11:21:04 +08:00
|
|
|
|
2020-02-07 00:28:32 +08:00
|
|
|
|
2022-08-05 01:11:01 +08:00
|
|
|
def module_add_dependencies(self, module, dependencies, optional=False):
|
|
|
|
"""
|
|
|
|
Adds dependencies for a given module.
|
|
|
|
Meant to be used in module `can_build` methods.
|
|
|
|
"""
|
|
|
|
if module not in self.module_dependencies:
|
|
|
|
self.module_dependencies[module] = [[], []]
|
|
|
|
if optional:
|
|
|
|
self.module_dependencies[module][1].extend(dependencies)
|
|
|
|
else:
|
|
|
|
self.module_dependencies[module][0].extend(dependencies)
|
|
|
|
|
|
|
|
|
|
|
|
def module_check_dependencies(self, module):
|
2020-06-02 19:16:42 +08:00
|
|
|
"""
|
|
|
|
Checks if module dependencies are enabled for a given module,
|
|
|
|
and prints a warning if they aren't.
|
|
|
|
Meant to be used in module `can_build` methods.
|
|
|
|
Returns a boolean (True if dependencies are satisfied).
|
|
|
|
"""
|
|
|
|
missing_deps = []
|
2022-08-05 01:11:01 +08:00
|
|
|
required_deps = self.module_dependencies[module][0] if module in self.module_dependencies else []
|
|
|
|
for dep in required_deps:
|
2020-06-02 19:16:42 +08:00
|
|
|
opt = "module_{}_enabled".format(dep)
|
2024-05-21 21:14:59 +08:00
|
|
|
if opt not in self or not self[opt]:
|
2020-06-02 19:16:42 +08:00
|
|
|
missing_deps.append(dep)
|
|
|
|
|
|
|
|
if missing_deps != []:
|
2024-04-27 01:35:07 +08:00
|
|
|
print_warning(
|
2022-08-05 01:11:01 +08:00
|
|
|
"Disabling '{}' module as the following dependencies are not satisfied: {}".format(
|
|
|
|
module, ", ".join(missing_deps)
|
2020-06-02 19:16:42 +08:00
|
|
|
)
|
2022-08-05 01:11:01 +08:00
|
|
|
)
|
2020-06-02 19:16:42 +08:00
|
|
|
return False
|
|
|
|
else:
|
|
|
|
return True
|
|
|
|
|
|
|
|
|
2022-08-05 01:11:01 +08:00
|
|
|
def sort_module_list(env):
|
|
|
|
deps = {k: v[0] + list(filter(lambda x: x in env.module_list, v[1])) for k, v in env.module_dependencies.items()}
|
|
|
|
|
|
|
|
frontier = list(env.module_list.keys())
|
|
|
|
explored = []
|
|
|
|
while len(frontier):
|
|
|
|
cur = frontier.pop()
|
|
|
|
deps_list = deps[cur] if cur in deps else []
|
|
|
|
if len(deps_list) and any([d not in explored for d in deps_list]):
|
|
|
|
# Will explore later, after its dependencies
|
|
|
|
frontier.insert(0, cur)
|
|
|
|
continue
|
|
|
|
explored.append(cur)
|
|
|
|
for k in explored:
|
|
|
|
env.module_list.move_to_end(k)
|
|
|
|
|
|
|
|
|
2016-06-14 22:27:16 +08:00
|
|
|
def use_windows_spawn_fix(self, platform=None):
|
2020-03-30 14:28:32 +08:00
|
|
|
if os.name != "nt":
|
2016-10-31 01:57:40 +08:00
|
|
|
return # not needed, only for windows
|
2016-01-25 11:21:04 +08:00
|
|
|
|
2016-10-29 09:34:53 +08:00
|
|
|
# On Windows, due to the limited command line length, when creating a static library
|
|
|
|
# from a very high number of objects SCons will invoke "ar" once per object file;
|
|
|
|
# that makes object files with same names to be overwritten so the last wins and
|
2021-03-12 21:35:16 +08:00
|
|
|
# the library loses symbols defined by overwritten objects.
|
2016-10-29 09:34:53 +08:00
|
|
|
# By enabling quick append instead of the default mode (replacing), libraries will
|
2018-02-22 00:30:55 +08:00
|
|
|
# got built correctly regardless the invocation strategy.
|
2016-10-29 09:34:53 +08:00
|
|
|
# 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.
|
2020-03-30 14:28:32 +08:00
|
|
|
self.Replace(ARFLAGS="q")
|
2016-01-25 11:21:04 +08:00
|
|
|
|
2016-10-31 01:57:40 +08:00
|
|
|
def mySubProcess(cmdline, env):
|
2016-10-31 01:44:57 +08:00
|
|
|
startupinfo = subprocess.STARTUPINFO()
|
|
|
|
startupinfo.dwFlags |= subprocess.STARTF_USESHOWWINDOW
|
2022-09-01 03:36:54 +08:00
|
|
|
popen_args = {
|
|
|
|
"stdin": subprocess.PIPE,
|
|
|
|
"stdout": subprocess.PIPE,
|
|
|
|
"stderr": subprocess.PIPE,
|
|
|
|
"startupinfo": startupinfo,
|
|
|
|
"shell": False,
|
|
|
|
"env": env,
|
|
|
|
}
|
|
|
|
if sys.version_info >= (3, 7, 0):
|
|
|
|
popen_args["text"] = True
|
|
|
|
proc = subprocess.Popen(cmdline, **popen_args)
|
2019-06-29 09:19:49 +08:00
|
|
|
_, err = proc.communicate()
|
2016-10-31 01:44:57 +08:00
|
|
|
rv = proc.wait()
|
|
|
|
if rv:
|
2024-04-27 01:35:07 +08:00
|
|
|
print_error(err)
|
2024-07-26 02:17:07 +08:00
|
|
|
elif len(err) > 0 and not err.isspace():
|
|
|
|
print(err)
|
2016-10-31 01:44:57 +08:00
|
|
|
return rv
|
2016-01-25 11:21:04 +08:00
|
|
|
|
|
|
|
def mySpawn(sh, escape, cmd, args, env):
|
2020-03-30 14:28:32 +08:00
|
|
|
newargs = " ".join(args[1:])
|
2016-10-31 01:44:57 +08:00
|
|
|
cmdline = cmd + " " + newargs
|
2016-01-25 11:21:04 +08:00
|
|
|
|
2016-10-31 01:57:40 +08:00
|
|
|
rv = 0
|
2020-03-25 21:36:03 +08:00
|
|
|
env = {str(key): str(value) for key, value in iter(env.items())}
|
2016-10-31 01:57:40 +08:00
|
|
|
if len(cmdline) > 32000 and cmd.endswith("ar"):
|
2016-10-31 01:44:57 +08:00
|
|
|
cmdline = cmd + " " + args[1] + " " + args[2] + " "
|
2016-10-31 01:57:40 +08:00
|
|
|
for i in range(3, len(args)):
|
|
|
|
rv = mySubProcess(cmdline + args[i], env)
|
|
|
|
if rv:
|
2016-10-31 01:44:57 +08:00
|
|
|
break
|
|
|
|
else:
|
2016-10-31 01:57:40 +08:00
|
|
|
rv = mySubProcess(cmdline, env)
|
2016-01-25 11:21:04 +08:00
|
|
|
|
2016-10-31 01:44:57 +08:00
|
|
|
return rv
|
2016-01-25 11:21:04 +08:00
|
|
|
|
2020-03-30 14:28:32 +08:00
|
|
|
self["SPAWN"] = mySpawn
|
2016-01-25 11:21:04 +08:00
|
|
|
|
|
|
|
|
2024-04-27 01:35:07 +08:00
|
|
|
def no_verbose(env):
|
2024-04-30 00:56:21 +08:00
|
|
|
colors = [ANSI.BLUE, ANSI.BOLD, ANSI.REGULAR, ANSI.RESET]
|
2020-03-30 14:28:32 +08:00
|
|
|
|
2021-12-16 03:08:28 +08:00
|
|
|
# There is a space before "..." to ensure that source file names can be
|
|
|
|
# Ctrl + clicked in the VS Code terminal.
|
2024-04-30 00:56:21 +08:00
|
|
|
compile_source_message = "{}Compiling {}$SOURCE{} ...{}".format(*colors)
|
|
|
|
java_compile_source_message = "{}Compiling {}$SOURCE{} ...{}".format(*colors)
|
|
|
|
compile_shared_source_message = "{}Compiling shared {}$SOURCE{} ...{}".format(*colors)
|
|
|
|
link_program_message = "{}Linking Program {}$TARGET{} ...{}".format(*colors)
|
|
|
|
link_library_message = "{}Linking Static Library {}$TARGET{} ...{}".format(*colors)
|
|
|
|
ranlib_library_message = "{}Ranlib Library {}$TARGET{} ...{}".format(*colors)
|
|
|
|
link_shared_library_message = "{}Linking Shared Library {}$TARGET{} ...{}".format(*colors)
|
|
|
|
java_library_message = "{}Creating Java Archive {}$TARGET{} ...{}".format(*colors)
|
|
|
|
compiled_resource_message = "{}Creating Compiled Resource {}$TARGET{} ...{}".format(*colors)
|
2024-05-17 01:56:27 +08:00
|
|
|
zip_archive_message = "{}Archiving {}$TARGET{} ...{}".format(*colors)
|
2024-04-30 00:56:21 +08:00
|
|
|
generated_file_message = "{}Generating {}$TARGET{} ...{}".format(*colors)
|
|
|
|
|
|
|
|
env["CXXCOMSTR"] = compile_source_message
|
|
|
|
env["CCCOMSTR"] = compile_source_message
|
|
|
|
env["SHCCCOMSTR"] = compile_shared_source_message
|
|
|
|
env["SHCXXCOMSTR"] = compile_shared_source_message
|
|
|
|
env["ARCOMSTR"] = link_library_message
|
|
|
|
env["RANLIBCOMSTR"] = ranlib_library_message
|
|
|
|
env["SHLINKCOMSTR"] = link_shared_library_message
|
|
|
|
env["LINKCOMSTR"] = link_program_message
|
|
|
|
env["JARCOMSTR"] = java_library_message
|
|
|
|
env["JAVACCOMSTR"] = java_compile_source_message
|
|
|
|
env["RCCOMSTR"] = compiled_resource_message
|
2024-05-17 01:56:27 +08:00
|
|
|
env["ZIPCOMSTR"] = zip_archive_message
|
2024-04-30 00:56:21 +08:00
|
|
|
env["GENCOMSTR"] = generated_file_message
|
2015-01-12 12:54:17 +08:00
|
|
|
|
2016-10-31 02:05:14 +08:00
|
|
|
|
2016-09-04 06:25:43 +08:00
|
|
|
def detect_visual_c_compiler_version(tools_env):
|
2016-10-31 01:44:57 +08:00
|
|
|
# tools_env is the variable scons uses to call tools that execute tasks, SCons's env['ENV'] that executes tasks...
|
|
|
|
# (see the SCons documentation for more information on what it does)...
|
2017-03-25 04:45:31 +08:00
|
|
|
# in order for this function to be well encapsulated i choose to force it to receive SCons's TOOLS env (env['ENV']
|
2016-10-31 01:44:57 +08:00
|
|
|
# and not scons setup environment (env)... so make sure you call the right environment on it or it will fail to detect
|
2017-03-25 04:45:31 +08:00
|
|
|
# the proper vc version that will be called
|
2016-10-31 01:44:57 +08:00
|
|
|
|
2021-12-16 09:38:10 +08:00
|
|
|
# There is no flag to give to visual c compilers to set the architecture, i.e. scons arch argument (x86_32, x86_64, arm64, etc.).
|
2016-10-31 01:44:57 +08:00
|
|
|
# There are many different cl.exe files that are run, and each one compiles & links to a different architecture
|
|
|
|
# As far as I know, the only way to figure out what compiler will be run when Scons calls cl.exe via Program()
|
2018-02-22 00:30:55 +08:00
|
|
|
# is to check the PATH variable and figure out which one will be called first. Code below does that and returns:
|
2016-10-31 01:44:57 +08:00
|
|
|
# the following string values:
|
|
|
|
|
|
|
|
# "" Compiler not detected
|
|
|
|
# "amd64" Native 64 bit compiler
|
|
|
|
# "amd64_x86" 64 bit Cross Compiler for 32 bit
|
|
|
|
# "x86" Native 32 bit compiler
|
|
|
|
# "x86_amd64" 32 bit Cross Compiler for 64 bit
|
|
|
|
|
|
|
|
# There are other architectures, but Godot does not support them currently, so this function does not detect arm/amd64_arm
|
|
|
|
# and similar architectures/compilers
|
|
|
|
|
|
|
|
# Set chosen compiler to "not detected"
|
|
|
|
vc_chosen_compiler_index = -1
|
|
|
|
vc_chosen_compiler_str = ""
|
|
|
|
|
2017-05-23 19:50:06 +08:00
|
|
|
# Start with Pre VS 2017 checks which uses VCINSTALLDIR:
|
2020-03-30 14:28:32 +08:00
|
|
|
if "VCINSTALLDIR" in tools_env:
|
2017-08-27 00:53:49 +08:00
|
|
|
# print("Checking VCINSTALLDIR")
|
2017-05-23 19:50:06 +08:00
|
|
|
|
2018-02-22 00:30:55 +08:00
|
|
|
# find() works with -1 so big ifs below are needed... the simplest solution, in fact
|
2017-05-23 19:50:06 +08:00
|
|
|
# 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;")
|
2020-03-30 14:28:32 +08:00
|
|
|
if vc_amd64_compiler_detection_index > -1:
|
2017-05-23 19:50:06 +08:00
|
|
|
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;")
|
2020-03-30 14:28:32 +08:00
|
|
|
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
|
|
|
|
):
|
2017-05-23 19:50:06 +08:00
|
|
|
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;")
|
2020-03-30 14:28:32 +08:00
|
|
|
if vc_x86_compiler_detection_index > -1 and (
|
|
|
|
vc_chosen_compiler_index == -1 or vc_chosen_compiler_index > vc_x86_compiler_detection_index
|
|
|
|
):
|
2017-05-23 19:50:06 +08:00
|
|
|
vc_chosen_compiler_index = vc_x86_compiler_detection_index
|
|
|
|
vc_chosen_compiler_str = "x86"
|
|
|
|
|
2020-03-30 14:28:32 +08:00
|
|
|
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
|
|
|
|
):
|
2017-05-23 19:50:06 +08:00
|
|
|
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:
|
2020-03-30 14:28:32 +08:00
|
|
|
if "VCTOOLSINSTALLDIR" in tools_env:
|
2017-05-23 19:50:06 +08:00
|
|
|
# Newer versions have a different path available
|
2020-03-30 14:28:32 +08:00
|
|
|
vc_amd64_compiler_detection_index = (
|
|
|
|
tools_env["PATH"].upper().find(tools_env["VCTOOLSINSTALLDIR"].upper() + "BIN\\HOSTX64\\X64;")
|
|
|
|
)
|
|
|
|
if vc_amd64_compiler_detection_index > -1:
|
2017-05-23 19:50:06 +08:00
|
|
|
vc_chosen_compiler_index = vc_amd64_compiler_detection_index
|
|
|
|
vc_chosen_compiler_str = "amd64"
|
|
|
|
|
2020-03-30 14:28:32 +08:00
|
|
|
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
|
|
|
|
):
|
2017-05-23 19:50:06 +08:00
|
|
|
vc_chosen_compiler_index = vc_amd64_x86_compiler_detection_index
|
|
|
|
vc_chosen_compiler_str = "amd64_x86"
|
|
|
|
|
2020-03-30 14:28:32 +08:00
|
|
|
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
|
|
|
|
):
|
2017-05-23 19:50:06 +08:00
|
|
|
vc_chosen_compiler_index = vc_x86_compiler_detection_index
|
|
|
|
vc_chosen_compiler_str = "x86"
|
|
|
|
|
2020-03-30 14:28:32 +08:00
|
|
|
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
|
|
|
|
):
|
2017-05-23 19:50:06 +08:00
|
|
|
vc_chosen_compiler_str = "x86_amd64"
|
2017-05-19 09:27:17 +08:00
|
|
|
|
2016-10-31 01:44:57 +08:00
|
|
|
return vc_chosen_compiler_str
|
2016-09-04 06:25:43 +08:00
|
|
|
|
2020-03-30 14:28:32 +08:00
|
|
|
|
2017-08-28 23:17:26 +08:00
|
|
|
def find_visual_c_batch_file(env):
|
2024-07-09 15:02:20 +08:00
|
|
|
# TODO: We should investigate if we can avoid relying on SCons internals here.
|
2024-05-21 21:14:59 +08:00
|
|
|
from SCons.Tool.MSCommon.vc import find_batch_file, find_vc_pdir, get_default_version, get_host_target
|
2017-08-28 23:17:26 +08:00
|
|
|
|
2023-11-26 03:49:01 +08:00
|
|
|
msvc_version = get_default_version(env)
|
2022-07-31 19:58:05 +08:00
|
|
|
|
2024-04-24 05:27:54 +08:00
|
|
|
# Syntax changed in SCons 4.4.0.
|
|
|
|
if env.scons_version >= (4, 4, 0):
|
2023-11-26 03:49:01 +08:00
|
|
|
(host_platform, target_platform, _) = get_host_target(env, msvc_version)
|
2022-07-31 19:58:05 +08:00
|
|
|
else:
|
|
|
|
(host_platform, target_platform, _) = get_host_target(env)
|
|
|
|
|
2024-04-24 05:27:54 +08:00
|
|
|
if env.scons_version < (4, 6, 0):
|
2023-11-26 03:49:01 +08:00
|
|
|
return find_batch_file(env, msvc_version, host_platform, target_platform)[0]
|
|
|
|
|
2024-07-09 15:02:20 +08:00
|
|
|
# SCons 4.6.0+ removed passing env, so we need to get the product_dir ourselves first,
|
2023-11-26 03:49:01 +08:00
|
|
|
# then pass that as the last param instead of env as the first param as before.
|
2024-07-09 15:02:20 +08:00
|
|
|
# Param names need to be explicit, as they were shuffled around in SCons 4.8.0.
|
|
|
|
product_dir = find_vc_pdir(msvc_version=msvc_version, env=env)
|
|
|
|
|
2023-11-26 03:49:01 +08:00
|
|
|
return find_batch_file(msvc_version, host_platform, target_platform, product_dir)[0]
|
2017-08-28 23:17:26 +08:00
|
|
|
|
2020-03-30 14:28:32 +08:00
|
|
|
|
2017-11-19 01:09:18 +08:00
|
|
|
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.
|
|
|
|
pass
|
|
|
|
else:
|
|
|
|
try:
|
2024-03-10 04:29:24 +08:00
|
|
|
with open(filename, "w", encoding="utf-8", newline="\n") as fd:
|
2018-03-11 01:37:33 +08:00
|
|
|
fd.write("#define GDCLASS(m_class, m_inherits)\n")
|
2024-06-30 01:55:09 +08:00
|
|
|
for name in ["GDVIRTUAL", "EXBIND", "MODBIND"]:
|
|
|
|
for count in range(13):
|
|
|
|
for suffix in ["", "R", "C", "RC"]:
|
|
|
|
fd.write(f"#define {name}{count}{suffix}(")
|
|
|
|
if "R" in suffix:
|
|
|
|
fd.write("m_ret, ")
|
|
|
|
fd.write("m_name")
|
|
|
|
for idx in range(1, count + 1):
|
|
|
|
fd.write(f", type{idx}")
|
|
|
|
fd.write(")\n")
|
|
|
|
|
2020-09-02 22:58:07 +08:00
|
|
|
except OSError:
|
2024-04-27 01:35:07 +08:00
|
|
|
print_warning("Could not write cpp.hint file.")
|
2017-08-28 23:17:26 +08:00
|
|
|
|
2020-03-30 14:28:32 +08:00
|
|
|
|
2020-09-19 22:39:11 +08:00
|
|
|
def glob_recursive(pattern, node="."):
|
2022-09-29 04:51:40 +08:00
|
|
|
from SCons import Node
|
|
|
|
from SCons.Script import Glob
|
|
|
|
|
2020-09-19 22:39:11 +08:00
|
|
|
results = []
|
|
|
|
for f in Glob(str(node) + "/*", source=True):
|
|
|
|
if type(f) is Node.FS.Dir:
|
|
|
|
results += glob_recursive(pattern, f)
|
|
|
|
results += Glob(str(node) + "/" + pattern, source=True)
|
|
|
|
return results
|
|
|
|
|
|
|
|
|
|
|
|
def add_to_vs_project(env, sources):
|
|
|
|
for x in sources:
|
2024-05-21 21:14:59 +08:00
|
|
|
fname = env.File(x).path if isinstance(x, str) else env.File(x)[0].path
|
2020-09-19 22:39:11 +08:00
|
|
|
pieces = fname.split(".")
|
|
|
|
if len(pieces) > 0:
|
|
|
|
basename = pieces[0]
|
|
|
|
basename = basename.replace("\\\\", "/")
|
|
|
|
if os.path.isfile(basename + ".h"):
|
|
|
|
env.vs_incs += [basename + ".h"]
|
|
|
|
elif os.path.isfile(basename + ".hpp"):
|
|
|
|
env.vs_incs += [basename + ".hpp"]
|
|
|
|
if os.path.isfile(basename + ".c"):
|
|
|
|
env.vs_srcs += [basename + ".c"]
|
|
|
|
elif os.path.isfile(basename + ".cpp"):
|
|
|
|
env.vs_srcs += [basename + ".cpp"]
|
|
|
|
|
|
|
|
|
2016-09-04 06:25:43 +08:00
|
|
|
def precious_program(env, program, sources, **args):
|
2016-10-31 01:44:57 +08:00
|
|
|
program = env.ProgramOriginal(program, sources, **args)
|
|
|
|
env.Precious(program)
|
|
|
|
return program
|
2017-11-29 04:27:57 +08:00
|
|
|
|
2020-03-30 14:28:32 +08:00
|
|
|
|
2017-11-29 04:27:57 +08:00
|
|
|
def add_shared_library(env, name, sources, **args):
|
2017-12-19 06:01:09 +08:00
|
|
|
library = env.SharedLibrary(name, sources, **args)
|
|
|
|
env.NoCache(library)
|
|
|
|
return library
|
2017-11-29 04:27:57 +08:00
|
|
|
|
2020-03-30 14:28:32 +08:00
|
|
|
|
2017-11-29 04:27:57 +08:00
|
|
|
def add_library(env, name, sources, **args):
|
2017-12-19 06:01:09 +08:00
|
|
|
library = env.Library(name, sources, **args)
|
|
|
|
env.NoCache(library)
|
|
|
|
return library
|
2017-11-29 04:27:57 +08:00
|
|
|
|
2020-03-30 14:28:32 +08:00
|
|
|
|
2017-11-29 04:27:57 +08:00
|
|
|
def add_program(env, name, sources, **args):
|
2017-12-19 06:01:09 +08:00
|
|
|
program = env.Program(name, sources, **args)
|
|
|
|
env.NoCache(program)
|
|
|
|
return program
|
2018-06-21 12:33:25 +08:00
|
|
|
|
2020-03-30 14:28:32 +08:00
|
|
|
|
2018-06-21 12:33:25 +08:00
|
|
|
def CommandNoCache(env, target, sources, command, **args):
|
|
|
|
result = env.Command(target, sources, command, **args)
|
|
|
|
env.NoCache(result)
|
|
|
|
return result
|
2018-08-24 08:03:57 +08:00
|
|
|
|
2020-03-30 14:28:32 +08:00
|
|
|
|
2024-03-12 02:05:37 +08:00
|
|
|
def Run(env, function):
|
2022-09-29 04:51:40 +08:00
|
|
|
from SCons.Script import Action
|
|
|
|
|
2024-03-12 02:05:37 +08:00
|
|
|
return Action(function, "$GENCOMSTR")
|
2020-07-28 02:00:26 +08:00
|
|
|
|
|
|
|
|
2018-08-24 08:03:57 +08:00
|
|
|
def detect_darwin_sdk_path(platform, env):
|
2020-03-30 14:28:32 +08:00
|
|
|
sdk_name = ""
|
2022-07-20 14:28:22 +08:00
|
|
|
if platform == "macos":
|
2020-03-30 14:28:32 +08:00
|
|
|
sdk_name = "macosx"
|
|
|
|
var_name = "MACOS_SDK_PATH"
|
2022-07-20 14:28:22 +08:00
|
|
|
elif platform == "ios":
|
2020-03-30 14:28:32 +08:00
|
|
|
sdk_name = "iphoneos"
|
2022-07-20 14:28:22 +08:00
|
|
|
var_name = "IOS_SDK_PATH"
|
|
|
|
elif platform == "iossimulator":
|
2020-03-30 14:28:32 +08:00
|
|
|
sdk_name = "iphonesimulator"
|
2022-07-20 14:28:22 +08:00
|
|
|
var_name = "IOS_SDK_PATH"
|
2018-08-24 08:03:57 +08:00
|
|
|
else:
|
|
|
|
raise Exception("Invalid platform argument passed to detect_darwin_sdk_path")
|
|
|
|
|
|
|
|
if not env[var_name]:
|
|
|
|
try:
|
2020-03-30 14:28:32 +08:00
|
|
|
sdk_path = subprocess.check_output(["xcrun", "--sdk", sdk_name, "--show-sdk-path"]).strip().decode("utf-8")
|
2018-08-24 08:03:57 +08:00
|
|
|
if sdk_path:
|
|
|
|
env[var_name] = sdk_path
|
2019-06-29 09:19:49 +08:00
|
|
|
except (subprocess.CalledProcessError, OSError):
|
2024-04-27 01:35:07 +08:00
|
|
|
print_error("Failed to find SDK path while running xcrun --sdk {} --show-sdk-path.".format(sdk_name))
|
2018-08-24 08:03:57 +08:00
|
|
|
raise
|
|
|
|
|
2020-03-30 14:28:32 +08:00
|
|
|
|
2020-02-24 17:03:58 +08:00
|
|
|
def is_vanilla_clang(env):
|
|
|
|
if not using_clang(env):
|
|
|
|
return False
|
2020-04-04 18:12:10 +08:00
|
|
|
try:
|
|
|
|
version = subprocess.check_output([env.subst(env["CXX"]), "--version"]).strip().decode("utf-8")
|
|
|
|
except (subprocess.CalledProcessError, OSError):
|
2024-04-27 01:35:07 +08:00
|
|
|
print_warning("Couldn't parse CXX environment variable to infer compiler version.")
|
2020-04-04 18:12:10 +08:00
|
|
|
return False
|
2020-02-24 17:03:58 +08:00
|
|
|
return not version.startswith("Apple")
|
|
|
|
|
|
|
|
|
2019-02-13 04:10:08 +08:00
|
|
|
def get_compiler_version(env):
|
2020-02-26 14:46:44 +08:00
|
|
|
"""
|
2023-09-26 03:08:36 +08:00
|
|
|
Returns a dictionary with various version information:
|
|
|
|
|
|
|
|
- major, minor, patch: Version following semantic versioning system
|
|
|
|
- metadata1, metadata2: Extra information
|
|
|
|
- date: Date of the build
|
2020-02-26 14:46:44 +08:00
|
|
|
"""
|
2023-09-26 03:08:36 +08:00
|
|
|
ret = {
|
|
|
|
"major": -1,
|
|
|
|
"minor": -1,
|
|
|
|
"patch": -1,
|
|
|
|
"metadata1": None,
|
|
|
|
"metadata2": None,
|
|
|
|
"date": None,
|
2023-11-22 15:05:45 +08:00
|
|
|
"apple_major": -1,
|
|
|
|
"apple_minor": -1,
|
|
|
|
"apple_patch1": -1,
|
|
|
|
"apple_patch2": -1,
|
|
|
|
"apple_patch3": -1,
|
2023-09-26 03:08:36 +08:00
|
|
|
}
|
|
|
|
|
2024-05-24 21:07:22 +08:00
|
|
|
if env.msvc and not using_clang(env):
|
2023-09-26 03:08:36 +08:00
|
|
|
# TODO: Implement for MSVC
|
|
|
|
return ret
|
2024-05-24 21:07:22 +08:00
|
|
|
|
|
|
|
# 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"], shell=(os.name == "nt"), encoding="utf-8"
|
|
|
|
).strip()
|
|
|
|
except (subprocess.CalledProcessError, OSError):
|
|
|
|
print_warning("Couldn't parse CXX environment variable to infer compiler version.")
|
|
|
|
return ret
|
|
|
|
|
2021-05-28 01:42:30 +08:00
|
|
|
match = re.search(
|
2023-09-25 16:39:30 +08:00
|
|
|
r"(?:(?<=version )|(?<=\) )|(?<=^))"
|
|
|
|
r"(?P<major>\d+)"
|
|
|
|
r"(?:\.(?P<minor>\d*))?"
|
|
|
|
r"(?:\.(?P<patch>\d*))?"
|
|
|
|
r"(?:-(?P<metadata1>[0-9a-zA-Z-]*))?"
|
|
|
|
r"(?:\+(?P<metadata2>[0-9a-zA-Z-]*))?"
|
|
|
|
r"(?: (?P<date>[0-9]{8}|[0-9]{6})(?![0-9a-zA-Z]))?",
|
2021-05-28 01:42:30 +08:00
|
|
|
version,
|
|
|
|
)
|
2019-02-13 04:10:08 +08:00
|
|
|
if match is not None:
|
2023-09-26 03:08:36 +08:00
|
|
|
for key, value in match.groupdict().items():
|
|
|
|
if value is not None:
|
|
|
|
ret[key] = value
|
2023-11-22 15:05:45 +08:00
|
|
|
|
|
|
|
match_apple = re.search(
|
|
|
|
r"(?:(?<=clang-)|(?<=\) )|(?<=^))"
|
|
|
|
r"(?P<apple_major>\d+)"
|
|
|
|
r"(?:\.(?P<apple_minor>\d*))?"
|
|
|
|
r"(?:\.(?P<apple_patch1>\d*))?"
|
|
|
|
r"(?:\.(?P<apple_patch2>\d*))?"
|
|
|
|
r"(?:\.(?P<apple_patch3>\d*))?",
|
|
|
|
version,
|
|
|
|
)
|
|
|
|
if match_apple is not None:
|
|
|
|
for key, value in match_apple.groupdict().items():
|
|
|
|
if value is not None:
|
|
|
|
ret[key] = value
|
|
|
|
|
2023-09-26 03:08:36 +08:00
|
|
|
# Transform semantic versioning to integers
|
2023-11-22 15:05:45 +08:00
|
|
|
for key in [
|
|
|
|
"major",
|
|
|
|
"minor",
|
|
|
|
"patch",
|
|
|
|
"apple_major",
|
|
|
|
"apple_minor",
|
|
|
|
"apple_patch1",
|
|
|
|
"apple_patch2",
|
|
|
|
"apple_patch3",
|
|
|
|
]:
|
2023-09-26 03:08:36 +08:00
|
|
|
ret[key] = int(ret[key] or -1)
|
|
|
|
return ret
|
2019-02-22 22:41:31 +08:00
|
|
|
|
2020-03-30 14:28:32 +08:00
|
|
|
|
2019-04-05 18:51:15 +08:00
|
|
|
def using_gcc(env):
|
2020-03-30 14:28:32 +08:00
|
|
|
return "gcc" in os.path.basename(env["CC"])
|
|
|
|
|
2019-04-05 18:51:15 +08:00
|
|
|
|
|
|
|
def using_clang(env):
|
2020-03-30 14:28:32 +08:00
|
|
|
return "clang" in os.path.basename(env["CC"])
|
2020-03-30 22:35:13 +08:00
|
|
|
|
|
|
|
|
2021-07-15 23:11:15 +08:00
|
|
|
def using_emcc(env):
|
|
|
|
return "emcc" in os.path.basename(env["CC"])
|
|
|
|
|
|
|
|
|
2020-03-30 22:35:13 +08:00
|
|
|
def show_progress(env):
|
2024-04-18 22:33:40 +08:00
|
|
|
if env["ninja"]:
|
|
|
|
# Has its own progress/tracking tool that clashes with ours
|
|
|
|
return
|
|
|
|
|
2020-03-30 22:35:13 +08:00
|
|
|
import sys
|
2024-05-21 21:14:59 +08:00
|
|
|
|
|
|
|
from SCons.Script import AlwaysBuild, Command, Progress
|
2020-03-30 22:35:13 +08:00
|
|
|
|
|
|
|
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()
|
|
|
|
node_count = 0
|
|
|
|
node_count_max = 0
|
|
|
|
node_count_interval = 1
|
|
|
|
node_count_fname = str(env.Dir("#")) + "/.scons_node_count"
|
|
|
|
|
2024-05-21 21:14:59 +08:00
|
|
|
import math
|
|
|
|
import time
|
2020-03-30 22:35:13 +08:00
|
|
|
|
|
|
|
class cache_progress:
|
|
|
|
# The default is 1 GB cache and 12 hours half life
|
|
|
|
def __init__(self, path=None, limit=1073741824, half_life=43200):
|
|
|
|
self.path = path
|
|
|
|
self.limit = limit
|
|
|
|
self.exponent_scale = math.log(2) / half_life
|
2024-05-21 21:14:59 +08:00
|
|
|
if env["verbose"] and path is not None:
|
2020-03-30 22:35:13 +08:00
|
|
|
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):
|
|
|
|
nonlocal node_count, node_count_max, node_count_interval, node_count_fname, show_progress
|
|
|
|
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))
|
|
|
|
screen.flush()
|
|
|
|
elif node_count_max > 0 and node_count > node_count_max:
|
|
|
|
screen.write("\r[100%] ")
|
|
|
|
screen.flush()
|
|
|
|
else:
|
|
|
|
screen.write("\r[Initial build] ")
|
|
|
|
screen.flush()
|
|
|
|
|
|
|
|
def delete(self, files):
|
|
|
|
if len(files) == 0:
|
|
|
|
return
|
|
|
|
if env["verbose"]:
|
|
|
|
# Utter something
|
|
|
|
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):
|
|
|
|
if self.path is None:
|
|
|
|
# Nothing to do
|
|
|
|
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, "*", "*"))]
|
|
|
|
if file_stat == []:
|
|
|
|
# Nothing to do
|
|
|
|
return []
|
|
|
|
# Weight the cache files by size (assumed to be roughly
|
|
|
|
# proportional to the recompilation time) times an exponential
|
|
|
|
# decay since the ctime, and return a list with the entries
|
|
|
|
# (filename, size, weight).
|
|
|
|
current_time = time.time()
|
|
|
|
file_stat = [(x[0], x[1][0], (current_time - x[1][1])) for x in file_stat]
|
|
|
|
# Sort by the most recently accessed files (most sensible to keep) first
|
|
|
|
file_stat.sort(key=lambda x: x[2])
|
|
|
|
# Search for the first entry where the storage limit is
|
|
|
|
# reached
|
|
|
|
sum, mark = 0, None
|
|
|
|
for i, x in enumerate(file_stat):
|
|
|
|
sum += x[1]
|
|
|
|
if sum > self.limit:
|
|
|
|
mark = i
|
|
|
|
break
|
|
|
|
if mark is None:
|
|
|
|
return []
|
|
|
|
else:
|
|
|
|
return [x[0] for x in file_stat[mark:]]
|
|
|
|
|
|
|
|
def convert_size(self, size_bytes):
|
|
|
|
if size_bytes == 0:
|
|
|
|
return "0 bytes"
|
|
|
|
size_name = ("bytes", "KB", "MB", "GB", "TB", "PB", "EB", "ZB", "YB")
|
|
|
|
i = int(math.floor(math.log(size_bytes, 1024)))
|
|
|
|
p = math.pow(1024, i)
|
|
|
|
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="."):
|
|
|
|
total_size = 0
|
|
|
|
for dirpath, dirnames, filenames in os.walk(start_path):
|
|
|
|
for f in filenames:
|
|
|
|
fp = os.path.join(dirpath, f)
|
|
|
|
total_size += os.path.getsize(fp)
|
|
|
|
return total_size
|
|
|
|
|
|
|
|
def progress_finish(target, source, env):
|
|
|
|
nonlocal node_count, progressor
|
2021-08-19 03:57:42 +08:00
|
|
|
try:
|
2024-03-10 04:29:24 +08:00
|
|
|
with open(node_count_fname, "w", encoding="utf-8", newline="\n") as f:
|
2021-08-19 03:57:42 +08:00
|
|
|
f.write("%d\n" % node_count)
|
|
|
|
progressor.delete(progressor.file_list())
|
|
|
|
except Exception:
|
|
|
|
pass
|
2020-03-30 22:35:13 +08:00
|
|
|
|
|
|
|
try:
|
2024-06-19 17:20:48 +08:00
|
|
|
with open(node_count_fname, "r", encoding="utf-8") as f:
|
2020-03-30 22:35:13 +08:00
|
|
|
node_count_max = int(f.readline())
|
2020-12-12 18:05:42 +08:00
|
|
|
except Exception:
|
2020-03-30 22:35:13 +08:00
|
|
|
pass
|
|
|
|
|
|
|
|
cache_directory = os.environ.get("SCONS_CACHE")
|
|
|
|
# Simple cache pruning, attached to SCons' progress callback. Trim the
|
|
|
|
# cache directory to a size not larger than cache_limit.
|
|
|
|
cache_limit = float(os.getenv("SCONS_CACHE_LIMIT", 1024)) * 1024 * 1024
|
|
|
|
progressor = cache_progress(cache_directory, cache_limit)
|
|
|
|
Progress(progressor, interval=node_count_interval)
|
|
|
|
|
|
|
|
progress_finish_command = Command("progress_finish", [], progress_finish)
|
|
|
|
AlwaysBuild(progress_finish_command)
|
2020-03-21 04:49:38 +08:00
|
|
|
|
|
|
|
|
|
|
|
def dump(env):
|
|
|
|
# Dumps latest build information for debugging purposes and external tools.
|
|
|
|
from json import dump
|
|
|
|
|
|
|
|
def non_serializable(obj):
|
|
|
|
return "<<non-serializable: %s>>" % (type(obj).__qualname__)
|
|
|
|
|
2024-03-10 04:29:24 +08:00
|
|
|
with open(".scons_env.json", "w", encoding="utf-8", newline="\n") as f:
|
2020-03-21 04:49:38 +08:00
|
|
|
dump(env.Dictionary(), f, indent=4, default=non_serializable)
|
Add new VS proj generation logic that supports any platform that wants to opt in
Custom Visual Studio project generation logic that supports any platform that has a msvs.py
script, so Visual Studio can be used to run scons for any platform, with the right defines per target.
Invoked with `scons vsproj=yes`
To generate build configuration files for all platforms+targets+arch combinations, users should call
```
scons vsproj=yes platform=XXX target=YYY [other build flags]
```
for each combination of platform+target[+arch]. This will generate the relevant vs project files but
skip the build process, so that project files can be quickly generated without waiting for a command line
build. This lets project files be quickly generated even if there are build errors.
All possible combinations of platform+target are created in the solution file by default, but they
won't do anything until each one is set up with a scons vsproj=yes command for the respective platform
in the appropriate command line. This lets users only generate the combinations they need, and VS
won't have to parse settings for other combos.
Only platforms that opt in to vs proj generation by having a msvs.py file in the platform folder are included.
Platforms with a msvs.py file will be added to the solution, but only the current active platform+target+arch
will have a build configuration generated, because we only know what the right defines/includes/flags/etc are
on the active build target currently being processed by scons.
Platforms that don't support an editor target will have a dummy editor target that won't do anything on build,
but will have the files and configuration for the windows editor target.
To generate AND build from the command line, run
```
scons vsproj=yes vsproj_gen_only=no
```
2023-11-14 20:39:44 +08:00
|
|
|
|
|
|
|
|
|
|
|
# Custom Visual Studio project generation logic that supports any platform that has a msvs.py
|
|
|
|
# script, so Visual Studio can be used to run scons for any platform, with the right defines per target.
|
|
|
|
# Invoked with scons vsproj=yes
|
|
|
|
#
|
|
|
|
# Only platforms that opt in to vs proj generation by having a msvs.py file in the platform folder are included.
|
|
|
|
# Platforms with a msvs.py file will be added to the solution, but only the current active platform+target+arch
|
|
|
|
# will have a build configuration generated, because we only know what the right defines/includes/flags/etc are
|
|
|
|
# on the active build target.
|
|
|
|
#
|
|
|
|
# Platforms that don't support an editor target will have a dummy editor target that won't do anything on build,
|
|
|
|
# but will have the files and configuration for the windows editor target.
|
|
|
|
#
|
|
|
|
# To generate build configuration files for all platforms+targets+arch combinations, users can call
|
|
|
|
# scons vsproj=yes
|
|
|
|
# for each combination of platform+target+arch. This will generate the relevant vs project files but
|
|
|
|
# skip the build process. This lets project files be quickly generated even if there are build errors.
|
|
|
|
#
|
|
|
|
# To generate AND build from the command line:
|
2024-06-30 01:55:09 +08:00
|
|
|
# scons vsproj=yes vsproj_gen_only=no
|
Add new VS proj generation logic that supports any platform that wants to opt in
Custom Visual Studio project generation logic that supports any platform that has a msvs.py
script, so Visual Studio can be used to run scons for any platform, with the right defines per target.
Invoked with `scons vsproj=yes`
To generate build configuration files for all platforms+targets+arch combinations, users should call
```
scons vsproj=yes platform=XXX target=YYY [other build flags]
```
for each combination of platform+target[+arch]. This will generate the relevant vs project files but
skip the build process, so that project files can be quickly generated without waiting for a command line
build. This lets project files be quickly generated even if there are build errors.
All possible combinations of platform+target are created in the solution file by default, but they
won't do anything until each one is set up with a scons vsproj=yes command for the respective platform
in the appropriate command line. This lets users only generate the combinations they need, and VS
won't have to parse settings for other combos.
Only platforms that opt in to vs proj generation by having a msvs.py file in the platform folder are included.
Platforms with a msvs.py file will be added to the solution, but only the current active platform+target+arch
will have a build configuration generated, because we only know what the right defines/includes/flags/etc are
on the active build target currently being processed by scons.
Platforms that don't support an editor target will have a dummy editor target that won't do anything on build,
but will have the files and configuration for the windows editor target.
To generate AND build from the command line, run
```
scons vsproj=yes vsproj_gen_only=no
```
2023-11-14 20:39:44 +08:00
|
|
|
def generate_vs_project(env, original_args, project_name="godot"):
|
|
|
|
# Augmented glob_recursive that also fills the dirs argument with traversed directories that have content.
|
|
|
|
def glob_recursive_2(pattern, dirs, node="."):
|
|
|
|
from SCons import Node
|
|
|
|
from SCons.Script import Glob
|
|
|
|
|
|
|
|
results = []
|
|
|
|
for f in Glob(str(node) + "/*", source=True):
|
|
|
|
if type(f) is Node.FS.Dir:
|
|
|
|
results += glob_recursive_2(pattern, dirs, f)
|
|
|
|
r = Glob(str(node) + "/" + pattern, source=True)
|
2024-05-21 21:14:59 +08:00
|
|
|
if len(r) > 0 and str(node) not in dirs:
|
Add new VS proj generation logic that supports any platform that wants to opt in
Custom Visual Studio project generation logic that supports any platform that has a msvs.py
script, so Visual Studio can be used to run scons for any platform, with the right defines per target.
Invoked with `scons vsproj=yes`
To generate build configuration files for all platforms+targets+arch combinations, users should call
```
scons vsproj=yes platform=XXX target=YYY [other build flags]
```
for each combination of platform+target[+arch]. This will generate the relevant vs project files but
skip the build process, so that project files can be quickly generated without waiting for a command line
build. This lets project files be quickly generated even if there are build errors.
All possible combinations of platform+target are created in the solution file by default, but they
won't do anything until each one is set up with a scons vsproj=yes command for the respective platform
in the appropriate command line. This lets users only generate the combinations they need, and VS
won't have to parse settings for other combos.
Only platforms that opt in to vs proj generation by having a msvs.py file in the platform folder are included.
Platforms with a msvs.py file will be added to the solution, but only the current active platform+target+arch
will have a build configuration generated, because we only know what the right defines/includes/flags/etc are
on the active build target currently being processed by scons.
Platforms that don't support an editor target will have a dummy editor target that won't do anything on build,
but will have the files and configuration for the windows editor target.
To generate AND build from the command line, run
```
scons vsproj=yes vsproj_gen_only=no
```
2023-11-14 20:39:44 +08:00
|
|
|
d = ""
|
|
|
|
for part in str(node).split("\\"):
|
|
|
|
d += part
|
2024-05-21 21:14:59 +08:00
|
|
|
if d not in dirs:
|
Add new VS proj generation logic that supports any platform that wants to opt in
Custom Visual Studio project generation logic that supports any platform that has a msvs.py
script, so Visual Studio can be used to run scons for any platform, with the right defines per target.
Invoked with `scons vsproj=yes`
To generate build configuration files for all platforms+targets+arch combinations, users should call
```
scons vsproj=yes platform=XXX target=YYY [other build flags]
```
for each combination of platform+target[+arch]. This will generate the relevant vs project files but
skip the build process, so that project files can be quickly generated without waiting for a command line
build. This lets project files be quickly generated even if there are build errors.
All possible combinations of platform+target are created in the solution file by default, but they
won't do anything until each one is set up with a scons vsproj=yes command for the respective platform
in the appropriate command line. This lets users only generate the combinations they need, and VS
won't have to parse settings for other combos.
Only platforms that opt in to vs proj generation by having a msvs.py file in the platform folder are included.
Platforms with a msvs.py file will be added to the solution, but only the current active platform+target+arch
will have a build configuration generated, because we only know what the right defines/includes/flags/etc are
on the active build target currently being processed by scons.
Platforms that don't support an editor target will have a dummy editor target that won't do anything on build,
but will have the files and configuration for the windows editor target.
To generate AND build from the command line, run
```
scons vsproj=yes vsproj_gen_only=no
```
2023-11-14 20:39:44 +08:00
|
|
|
dirs.append(d)
|
|
|
|
d += "\\"
|
|
|
|
results += r
|
|
|
|
return results
|
|
|
|
|
|
|
|
def get_bool(args, option, default):
|
|
|
|
from SCons.Variables.BoolVariable import _text2bool
|
|
|
|
|
|
|
|
val = args.get(option, default)
|
|
|
|
if val is not None:
|
|
|
|
try:
|
|
|
|
return _text2bool(val)
|
2024-05-21 21:14:59 +08:00
|
|
|
except (ValueError, AttributeError):
|
Add new VS proj generation logic that supports any platform that wants to opt in
Custom Visual Studio project generation logic that supports any platform that has a msvs.py
script, so Visual Studio can be used to run scons for any platform, with the right defines per target.
Invoked with `scons vsproj=yes`
To generate build configuration files for all platforms+targets+arch combinations, users should call
```
scons vsproj=yes platform=XXX target=YYY [other build flags]
```
for each combination of platform+target[+arch]. This will generate the relevant vs project files but
skip the build process, so that project files can be quickly generated without waiting for a command line
build. This lets project files be quickly generated even if there are build errors.
All possible combinations of platform+target are created in the solution file by default, but they
won't do anything until each one is set up with a scons vsproj=yes command for the respective platform
in the appropriate command line. This lets users only generate the combinations they need, and VS
won't have to parse settings for other combos.
Only platforms that opt in to vs proj generation by having a msvs.py file in the platform folder are included.
Platforms with a msvs.py file will be added to the solution, but only the current active platform+target+arch
will have a build configuration generated, because we only know what the right defines/includes/flags/etc are
on the active build target currently being processed by scons.
Platforms that don't support an editor target will have a dummy editor target that won't do anything on build,
but will have the files and configuration for the windows editor target.
To generate AND build from the command line, run
```
scons vsproj=yes vsproj_gen_only=no
```
2023-11-14 20:39:44 +08:00
|
|
|
return default
|
|
|
|
else:
|
|
|
|
return default
|
|
|
|
|
|
|
|
def format_key_value(v):
|
|
|
|
if type(v) in [tuple, list]:
|
|
|
|
return v[0] if len(v) == 1 else f"{v[0]}={v[1]}"
|
|
|
|
return v
|
|
|
|
|
|
|
|
filtered_args = original_args.copy()
|
|
|
|
|
|
|
|
# Ignore the "vsproj" option to not regenerate the VS project on every build
|
|
|
|
filtered_args.pop("vsproj", None)
|
|
|
|
|
|
|
|
# This flag allows users to regenerate the proj files but skip the building process.
|
|
|
|
# This lets projects be regenerated even if there are build errors.
|
|
|
|
filtered_args.pop("vsproj_gen_only", None)
|
|
|
|
|
2024-02-15 20:06:34 +08:00
|
|
|
# This flag allows users to regenerate only the props file without touching the sln or vcxproj files.
|
|
|
|
# This preserves any customizations users have done to the solution, while still updating the file list
|
|
|
|
# and build commands.
|
|
|
|
filtered_args.pop("vsproj_props_only", None)
|
|
|
|
|
Add new VS proj generation logic that supports any platform that wants to opt in
Custom Visual Studio project generation logic that supports any platform that has a msvs.py
script, so Visual Studio can be used to run scons for any platform, with the right defines per target.
Invoked with `scons vsproj=yes`
To generate build configuration files for all platforms+targets+arch combinations, users should call
```
scons vsproj=yes platform=XXX target=YYY [other build flags]
```
for each combination of platform+target[+arch]. This will generate the relevant vs project files but
skip the build process, so that project files can be quickly generated without waiting for a command line
build. This lets project files be quickly generated even if there are build errors.
All possible combinations of platform+target are created in the solution file by default, but they
won't do anything until each one is set up with a scons vsproj=yes command for the respective platform
in the appropriate command line. This lets users only generate the combinations they need, and VS
won't have to parse settings for other combos.
Only platforms that opt in to vs proj generation by having a msvs.py file in the platform folder are included.
Platforms with a msvs.py file will be added to the solution, but only the current active platform+target+arch
will have a build configuration generated, because we only know what the right defines/includes/flags/etc are
on the active build target currently being processed by scons.
Platforms that don't support an editor target will have a dummy editor target that won't do anything on build,
but will have the files and configuration for the windows editor target.
To generate AND build from the command line, run
```
scons vsproj=yes vsproj_gen_only=no
```
2023-11-14 20:39:44 +08:00
|
|
|
# The "progress" option is ignored as the current compilation progress indication doesn't work in VS
|
|
|
|
filtered_args.pop("progress", None)
|
|
|
|
|
|
|
|
# We add these three manually because they might not be explicitly passed in, and it's important to always set them.
|
|
|
|
filtered_args.pop("platform", None)
|
|
|
|
filtered_args.pop("target", None)
|
|
|
|
filtered_args.pop("arch", None)
|
|
|
|
|
|
|
|
platform = env["platform"]
|
|
|
|
target = env["target"]
|
|
|
|
arch = env["arch"]
|
|
|
|
|
|
|
|
vs_configuration = {}
|
|
|
|
common_build_prefix = []
|
|
|
|
confs = []
|
|
|
|
for x in sorted(glob.glob("platform/*")):
|
|
|
|
# Only platforms that opt in to vs proj generation are included.
|
|
|
|
if not os.path.isdir(x) or not os.path.exists(x + "/msvs.py"):
|
|
|
|
continue
|
|
|
|
tmppath = "./" + x
|
|
|
|
sys.path.insert(0, tmppath)
|
|
|
|
import msvs
|
|
|
|
|
|
|
|
vs_plats = []
|
|
|
|
vs_confs = []
|
|
|
|
try:
|
|
|
|
platform_name = x[9:]
|
|
|
|
vs_plats = msvs.get_platforms()
|
|
|
|
vs_confs = msvs.get_configurations()
|
|
|
|
val = []
|
|
|
|
for plat in vs_plats:
|
|
|
|
val += [{"platform": plat[0], "architecture": plat[1]}]
|
|
|
|
|
|
|
|
vsconf = {"platform": platform_name, "targets": vs_confs, "arches": val}
|
|
|
|
confs += [vsconf]
|
|
|
|
|
|
|
|
# Save additional information about the configuration for the actively selected platform,
|
|
|
|
# so we can generate the platform-specific props file with all the build commands/defines/etc
|
|
|
|
if platform == platform_name:
|
|
|
|
common_build_prefix = msvs.get_build_prefix(env)
|
|
|
|
vs_configuration = vsconf
|
|
|
|
except Exception:
|
|
|
|
pass
|
|
|
|
|
|
|
|
sys.path.remove(tmppath)
|
|
|
|
sys.modules.pop("msvs")
|
|
|
|
|
|
|
|
headers = []
|
|
|
|
headers_dirs = []
|
|
|
|
for file in glob_recursive_2("*.h", headers_dirs):
|
|
|
|
headers.append(str(file).replace("/", "\\"))
|
|
|
|
for file in glob_recursive_2("*.hpp", headers_dirs):
|
|
|
|
headers.append(str(file).replace("/", "\\"))
|
|
|
|
|
|
|
|
sources = []
|
|
|
|
sources_dirs = []
|
|
|
|
for file in glob_recursive_2("*.cpp", sources_dirs):
|
|
|
|
sources.append(str(file).replace("/", "\\"))
|
|
|
|
for file in glob_recursive_2("*.c", sources_dirs):
|
|
|
|
sources.append(str(file).replace("/", "\\"))
|
|
|
|
|
|
|
|
others = []
|
|
|
|
others_dirs = []
|
|
|
|
for file in glob_recursive_2("*.natvis", others_dirs):
|
|
|
|
others.append(str(file).replace("/", "\\"))
|
|
|
|
for file in glob_recursive_2("*.glsl", others_dirs):
|
|
|
|
others.append(str(file).replace("/", "\\"))
|
|
|
|
|
|
|
|
skip_filters = False
|
|
|
|
import hashlib
|
|
|
|
import json
|
|
|
|
|
|
|
|
md5 = hashlib.md5(
|
|
|
|
json.dumps(headers + headers_dirs + sources + sources_dirs + others + others_dirs, sort_keys=True).encode(
|
|
|
|
"utf-8"
|
|
|
|
)
|
|
|
|
).hexdigest()
|
|
|
|
|
|
|
|
if os.path.exists(f"{project_name}.vcxproj.filters"):
|
2024-03-25 01:02:56 +08:00
|
|
|
with open(f"{project_name}.vcxproj.filters", "r", encoding="utf-8") as file:
|
2024-03-11 01:09:48 +08:00
|
|
|
existing_filters = file.read()
|
Add new VS proj generation logic that supports any platform that wants to opt in
Custom Visual Studio project generation logic that supports any platform that has a msvs.py
script, so Visual Studio can be used to run scons for any platform, with the right defines per target.
Invoked with `scons vsproj=yes`
To generate build configuration files for all platforms+targets+arch combinations, users should call
```
scons vsproj=yes platform=XXX target=YYY [other build flags]
```
for each combination of platform+target[+arch]. This will generate the relevant vs project files but
skip the build process, so that project files can be quickly generated without waiting for a command line
build. This lets project files be quickly generated even if there are build errors.
All possible combinations of platform+target are created in the solution file by default, but they
won't do anything until each one is set up with a scons vsproj=yes command for the respective platform
in the appropriate command line. This lets users only generate the combinations they need, and VS
won't have to parse settings for other combos.
Only platforms that opt in to vs proj generation by having a msvs.py file in the platform folder are included.
Platforms with a msvs.py file will be added to the solution, but only the current active platform+target+arch
will have a build configuration generated, because we only know what the right defines/includes/flags/etc are
on the active build target currently being processed by scons.
Platforms that don't support an editor target will have a dummy editor target that won't do anything on build,
but will have the files and configuration for the windows editor target.
To generate AND build from the command line, run
```
scons vsproj=yes vsproj_gen_only=no
```
2023-11-14 20:39:44 +08:00
|
|
|
match = re.search(r"(?ms)^<!-- CHECKSUM$.([0-9a-f]{32})", existing_filters)
|
|
|
|
if match is not None and md5 == match.group(1):
|
|
|
|
skip_filters = True
|
|
|
|
|
|
|
|
import uuid
|
|
|
|
|
|
|
|
# Don't regenerate the filters file if nothing has changed, so we keep the existing UUIDs.
|
|
|
|
if not skip_filters:
|
|
|
|
print(f"Regenerating {project_name}.vcxproj.filters")
|
|
|
|
|
2024-03-25 01:02:56 +08:00
|
|
|
with open("misc/msvs/vcxproj.filters.template", "r", encoding="utf-8") as file:
|
2024-03-11 01:09:48 +08:00
|
|
|
filters_template = file.read()
|
Add new VS proj generation logic that supports any platform that wants to opt in
Custom Visual Studio project generation logic that supports any platform that has a msvs.py
script, so Visual Studio can be used to run scons for any platform, with the right defines per target.
Invoked with `scons vsproj=yes`
To generate build configuration files for all platforms+targets+arch combinations, users should call
```
scons vsproj=yes platform=XXX target=YYY [other build flags]
```
for each combination of platform+target[+arch]. This will generate the relevant vs project files but
skip the build process, so that project files can be quickly generated without waiting for a command line
build. This lets project files be quickly generated even if there are build errors.
All possible combinations of platform+target are created in the solution file by default, but they
won't do anything until each one is set up with a scons vsproj=yes command for the respective platform
in the appropriate command line. This lets users only generate the combinations they need, and VS
won't have to parse settings for other combos.
Only platforms that opt in to vs proj generation by having a msvs.py file in the platform folder are included.
Platforms with a msvs.py file will be added to the solution, but only the current active platform+target+arch
will have a build configuration generated, because we only know what the right defines/includes/flags/etc are
on the active build target currently being processed by scons.
Platforms that don't support an editor target will have a dummy editor target that won't do anything on build,
but will have the files and configuration for the windows editor target.
To generate AND build from the command line, run
```
scons vsproj=yes vsproj_gen_only=no
```
2023-11-14 20:39:44 +08:00
|
|
|
for i in range(1, 10):
|
|
|
|
filters_template = filters_template.replace(f"%%UUID{i}%%", str(uuid.uuid4()))
|
|
|
|
|
|
|
|
filters = ""
|
|
|
|
|
|
|
|
for d in headers_dirs:
|
|
|
|
filters += f'<Filter Include="Header Files\\{d}"><UniqueIdentifier>{{{str(uuid.uuid4())}}}</UniqueIdentifier></Filter>\n'
|
|
|
|
for d in sources_dirs:
|
|
|
|
filters += f'<Filter Include="Source Files\\{d}"><UniqueIdentifier>{{{str(uuid.uuid4())}}}</UniqueIdentifier></Filter>\n'
|
|
|
|
for d in others_dirs:
|
|
|
|
filters += f'<Filter Include="Other Files\\{d}"><UniqueIdentifier>{{{str(uuid.uuid4())}}}</UniqueIdentifier></Filter>\n'
|
|
|
|
|
|
|
|
filters_template = filters_template.replace("%%FILTERS%%", filters)
|
|
|
|
|
|
|
|
filters = ""
|
|
|
|
for file in headers:
|
|
|
|
filters += (
|
|
|
|
f'<ClInclude Include="{file}"><Filter>Header Files\\{os.path.dirname(file)}</Filter></ClInclude>\n'
|
|
|
|
)
|
|
|
|
filters_template = filters_template.replace("%%INCLUDES%%", filters)
|
|
|
|
|
|
|
|
filters = ""
|
|
|
|
for file in sources:
|
|
|
|
filters += (
|
|
|
|
f'<ClCompile Include="{file}"><Filter>Source Files\\{os.path.dirname(file)}</Filter></ClCompile>\n'
|
|
|
|
)
|
|
|
|
|
|
|
|
filters_template = filters_template.replace("%%COMPILES%%", filters)
|
|
|
|
|
|
|
|
filters = ""
|
|
|
|
for file in others:
|
|
|
|
filters += f'<None Include="{file}"><Filter>Other Files\\{os.path.dirname(file)}</Filter></None>\n'
|
|
|
|
filters_template = filters_template.replace("%%OTHERS%%", filters)
|
|
|
|
|
|
|
|
filters_template = filters_template.replace("%%HASH%%", md5)
|
|
|
|
|
2024-04-10 22:59:57 +08:00
|
|
|
with open(f"{project_name}.vcxproj.filters", "w", encoding="utf-8", newline="\r\n") as f:
|
Add new VS proj generation logic that supports any platform that wants to opt in
Custom Visual Studio project generation logic that supports any platform that has a msvs.py
script, so Visual Studio can be used to run scons for any platform, with the right defines per target.
Invoked with `scons vsproj=yes`
To generate build configuration files for all platforms+targets+arch combinations, users should call
```
scons vsproj=yes platform=XXX target=YYY [other build flags]
```
for each combination of platform+target[+arch]. This will generate the relevant vs project files but
skip the build process, so that project files can be quickly generated without waiting for a command line
build. This lets project files be quickly generated even if there are build errors.
All possible combinations of platform+target are created in the solution file by default, but they
won't do anything until each one is set up with a scons vsproj=yes command for the respective platform
in the appropriate command line. This lets users only generate the combinations they need, and VS
won't have to parse settings for other combos.
Only platforms that opt in to vs proj generation by having a msvs.py file in the platform folder are included.
Platforms with a msvs.py file will be added to the solution, but only the current active platform+target+arch
will have a build configuration generated, because we only know what the right defines/includes/flags/etc are
on the active build target currently being processed by scons.
Platforms that don't support an editor target will have a dummy editor target that won't do anything on build,
but will have the files and configuration for the windows editor target.
To generate AND build from the command line, run
```
scons vsproj=yes vsproj_gen_only=no
```
2023-11-14 20:39:44 +08:00
|
|
|
f.write(filters_template)
|
|
|
|
|
|
|
|
envsources = []
|
|
|
|
|
|
|
|
envsources += env.core_sources
|
|
|
|
envsources += env.drivers_sources
|
|
|
|
envsources += env.main_sources
|
|
|
|
envsources += env.modules_sources
|
|
|
|
envsources += env.scene_sources
|
|
|
|
envsources += env.servers_sources
|
|
|
|
if env.editor_build:
|
|
|
|
envsources += env.editor_sources
|
|
|
|
envsources += env.platform_sources
|
|
|
|
|
|
|
|
headers_active = []
|
|
|
|
sources_active = []
|
|
|
|
others_active = []
|
|
|
|
for x in envsources:
|
|
|
|
fname = ""
|
2024-05-21 21:14:59 +08:00
|
|
|
if isinstance(x, str):
|
Add new VS proj generation logic that supports any platform that wants to opt in
Custom Visual Studio project generation logic that supports any platform that has a msvs.py
script, so Visual Studio can be used to run scons for any platform, with the right defines per target.
Invoked with `scons vsproj=yes`
To generate build configuration files for all platforms+targets+arch combinations, users should call
```
scons vsproj=yes platform=XXX target=YYY [other build flags]
```
for each combination of platform+target[+arch]. This will generate the relevant vs project files but
skip the build process, so that project files can be quickly generated without waiting for a command line
build. This lets project files be quickly generated even if there are build errors.
All possible combinations of platform+target are created in the solution file by default, but they
won't do anything until each one is set up with a scons vsproj=yes command for the respective platform
in the appropriate command line. This lets users only generate the combinations they need, and VS
won't have to parse settings for other combos.
Only platforms that opt in to vs proj generation by having a msvs.py file in the platform folder are included.
Platforms with a msvs.py file will be added to the solution, but only the current active platform+target+arch
will have a build configuration generated, because we only know what the right defines/includes/flags/etc are
on the active build target currently being processed by scons.
Platforms that don't support an editor target will have a dummy editor target that won't do anything on build,
but will have the files and configuration for the windows editor target.
To generate AND build from the command line, run
```
scons vsproj=yes vsproj_gen_only=no
```
2023-11-14 20:39:44 +08:00
|
|
|
fname = env.File(x).path
|
|
|
|
else:
|
|
|
|
# Some object files might get added directly as a File object and not a list.
|
|
|
|
try:
|
|
|
|
fname = env.File(x)[0].path
|
2024-05-21 21:14:59 +08:00
|
|
|
except Exception:
|
Add new VS proj generation logic that supports any platform that wants to opt in
Custom Visual Studio project generation logic that supports any platform that has a msvs.py
script, so Visual Studio can be used to run scons for any platform, with the right defines per target.
Invoked with `scons vsproj=yes`
To generate build configuration files for all platforms+targets+arch combinations, users should call
```
scons vsproj=yes platform=XXX target=YYY [other build flags]
```
for each combination of platform+target[+arch]. This will generate the relevant vs project files but
skip the build process, so that project files can be quickly generated without waiting for a command line
build. This lets project files be quickly generated even if there are build errors.
All possible combinations of platform+target are created in the solution file by default, but they
won't do anything until each one is set up with a scons vsproj=yes command for the respective platform
in the appropriate command line. This lets users only generate the combinations they need, and VS
won't have to parse settings for other combos.
Only platforms that opt in to vs proj generation by having a msvs.py file in the platform folder are included.
Platforms with a msvs.py file will be added to the solution, but only the current active platform+target+arch
will have a build configuration generated, because we only know what the right defines/includes/flags/etc are
on the active build target currently being processed by scons.
Platforms that don't support an editor target will have a dummy editor target that won't do anything on build,
but will have the files and configuration for the windows editor target.
To generate AND build from the command line, run
```
scons vsproj=yes vsproj_gen_only=no
```
2023-11-14 20:39:44 +08:00
|
|
|
fname = x.path
|
|
|
|
pass
|
|
|
|
|
|
|
|
if fname:
|
|
|
|
fname = fname.replace("\\\\", "/")
|
|
|
|
parts = os.path.splitext(fname)
|
|
|
|
basename = parts[0]
|
|
|
|
ext = parts[1]
|
|
|
|
idx = fname.find(env["OBJSUFFIX"])
|
|
|
|
if ext in [".h", ".hpp"]:
|
|
|
|
headers_active += [fname]
|
|
|
|
elif ext in [".c", ".cpp"]:
|
|
|
|
sources_active += [fname]
|
|
|
|
elif idx > 0:
|
|
|
|
basename = fname[:idx]
|
|
|
|
if os.path.isfile(basename + ".h"):
|
|
|
|
headers_active += [basename + ".h"]
|
|
|
|
elif os.path.isfile(basename + ".hpp"):
|
|
|
|
headers_active += [basename + ".hpp"]
|
|
|
|
elif basename.endswith(".gen") and os.path.isfile(basename[:-4] + ".h"):
|
|
|
|
headers_active += [basename[:-4] + ".h"]
|
|
|
|
if os.path.isfile(basename + ".c"):
|
|
|
|
sources_active += [basename + ".c"]
|
|
|
|
elif os.path.isfile(basename + ".cpp"):
|
|
|
|
sources_active += [basename + ".cpp"]
|
|
|
|
else:
|
|
|
|
fname = os.path.relpath(os.path.abspath(fname), env.Dir("").abspath)
|
|
|
|
others_active += [fname]
|
|
|
|
|
|
|
|
all_items = []
|
|
|
|
properties = []
|
|
|
|
activeItems = []
|
|
|
|
extraItems = []
|
|
|
|
|
|
|
|
set_headers = set(headers_active)
|
|
|
|
set_sources = set(sources_active)
|
|
|
|
set_others = set(others_active)
|
|
|
|
for file in headers:
|
2024-02-15 20:06:34 +08:00
|
|
|
base_path = os.path.dirname(file).replace("\\", "_")
|
Add new VS proj generation logic that supports any platform that wants to opt in
Custom Visual Studio project generation logic that supports any platform that has a msvs.py
script, so Visual Studio can be used to run scons for any platform, with the right defines per target.
Invoked with `scons vsproj=yes`
To generate build configuration files for all platforms+targets+arch combinations, users should call
```
scons vsproj=yes platform=XXX target=YYY [other build flags]
```
for each combination of platform+target[+arch]. This will generate the relevant vs project files but
skip the build process, so that project files can be quickly generated without waiting for a command line
build. This lets project files be quickly generated even if there are build errors.
All possible combinations of platform+target are created in the solution file by default, but they
won't do anything until each one is set up with a scons vsproj=yes command for the respective platform
in the appropriate command line. This lets users only generate the combinations they need, and VS
won't have to parse settings for other combos.
Only platforms that opt in to vs proj generation by having a msvs.py file in the platform folder are included.
Platforms with a msvs.py file will be added to the solution, but only the current active platform+target+arch
will have a build configuration generated, because we only know what the right defines/includes/flags/etc are
on the active build target currently being processed by scons.
Platforms that don't support an editor target will have a dummy editor target that won't do anything on build,
but will have the files and configuration for the windows editor target.
To generate AND build from the command line, run
```
scons vsproj=yes vsproj_gen_only=no
```
2023-11-14 20:39:44 +08:00
|
|
|
all_items.append(f'<ClInclude Include="{file}">')
|
|
|
|
all_items.append(
|
2024-02-15 20:06:34 +08:00
|
|
|
f" <ExcludedFromBuild Condition=\"!$(ActiveProjectItemList_{base_path}.Contains(';{file};'))\">true</ExcludedFromBuild>"
|
Add new VS proj generation logic that supports any platform that wants to opt in
Custom Visual Studio project generation logic that supports any platform that has a msvs.py
script, so Visual Studio can be used to run scons for any platform, with the right defines per target.
Invoked with `scons vsproj=yes`
To generate build configuration files for all platforms+targets+arch combinations, users should call
```
scons vsproj=yes platform=XXX target=YYY [other build flags]
```
for each combination of platform+target[+arch]. This will generate the relevant vs project files but
skip the build process, so that project files can be quickly generated without waiting for a command line
build. This lets project files be quickly generated even if there are build errors.
All possible combinations of platform+target are created in the solution file by default, but they
won't do anything until each one is set up with a scons vsproj=yes command for the respective platform
in the appropriate command line. This lets users only generate the combinations they need, and VS
won't have to parse settings for other combos.
Only platforms that opt in to vs proj generation by having a msvs.py file in the platform folder are included.
Platforms with a msvs.py file will be added to the solution, but only the current active platform+target+arch
will have a build configuration generated, because we only know what the right defines/includes/flags/etc are
on the active build target currently being processed by scons.
Platforms that don't support an editor target will have a dummy editor target that won't do anything on build,
but will have the files and configuration for the windows editor target.
To generate AND build from the command line, run
```
scons vsproj=yes vsproj_gen_only=no
```
2023-11-14 20:39:44 +08:00
|
|
|
)
|
|
|
|
all_items.append("</ClInclude>")
|
|
|
|
if file in set_headers:
|
|
|
|
activeItems.append(file)
|
|
|
|
|
|
|
|
for file in sources:
|
2024-02-15 20:06:34 +08:00
|
|
|
base_path = os.path.dirname(file).replace("\\", "_")
|
Add new VS proj generation logic that supports any platform that wants to opt in
Custom Visual Studio project generation logic that supports any platform that has a msvs.py
script, so Visual Studio can be used to run scons for any platform, with the right defines per target.
Invoked with `scons vsproj=yes`
To generate build configuration files for all platforms+targets+arch combinations, users should call
```
scons vsproj=yes platform=XXX target=YYY [other build flags]
```
for each combination of platform+target[+arch]. This will generate the relevant vs project files but
skip the build process, so that project files can be quickly generated without waiting for a command line
build. This lets project files be quickly generated even if there are build errors.
All possible combinations of platform+target are created in the solution file by default, but they
won't do anything until each one is set up with a scons vsproj=yes command for the respective platform
in the appropriate command line. This lets users only generate the combinations they need, and VS
won't have to parse settings for other combos.
Only platforms that opt in to vs proj generation by having a msvs.py file in the platform folder are included.
Platforms with a msvs.py file will be added to the solution, but only the current active platform+target+arch
will have a build configuration generated, because we only know what the right defines/includes/flags/etc are
on the active build target currently being processed by scons.
Platforms that don't support an editor target will have a dummy editor target that won't do anything on build,
but will have the files and configuration for the windows editor target.
To generate AND build from the command line, run
```
scons vsproj=yes vsproj_gen_only=no
```
2023-11-14 20:39:44 +08:00
|
|
|
all_items.append(f'<ClCompile Include="{file}">')
|
|
|
|
all_items.append(
|
2024-02-15 20:06:34 +08:00
|
|
|
f" <ExcludedFromBuild Condition=\"!$(ActiveProjectItemList_{base_path}.Contains(';{file};'))\">true</ExcludedFromBuild>"
|
Add new VS proj generation logic that supports any platform that wants to opt in
Custom Visual Studio project generation logic that supports any platform that has a msvs.py
script, so Visual Studio can be used to run scons for any platform, with the right defines per target.
Invoked with `scons vsproj=yes`
To generate build configuration files for all platforms+targets+arch combinations, users should call
```
scons vsproj=yes platform=XXX target=YYY [other build flags]
```
for each combination of platform+target[+arch]. This will generate the relevant vs project files but
skip the build process, so that project files can be quickly generated without waiting for a command line
build. This lets project files be quickly generated even if there are build errors.
All possible combinations of platform+target are created in the solution file by default, but they
won't do anything until each one is set up with a scons vsproj=yes command for the respective platform
in the appropriate command line. This lets users only generate the combinations they need, and VS
won't have to parse settings for other combos.
Only platforms that opt in to vs proj generation by having a msvs.py file in the platform folder are included.
Platforms with a msvs.py file will be added to the solution, but only the current active platform+target+arch
will have a build configuration generated, because we only know what the right defines/includes/flags/etc are
on the active build target currently being processed by scons.
Platforms that don't support an editor target will have a dummy editor target that won't do anything on build,
but will have the files and configuration for the windows editor target.
To generate AND build from the command line, run
```
scons vsproj=yes vsproj_gen_only=no
```
2023-11-14 20:39:44 +08:00
|
|
|
)
|
|
|
|
all_items.append("</ClCompile>")
|
|
|
|
if file in set_sources:
|
|
|
|
activeItems.append(file)
|
|
|
|
|
|
|
|
for file in others:
|
2024-02-15 20:06:34 +08:00
|
|
|
base_path = os.path.dirname(file).replace("\\", "_")
|
Add new VS proj generation logic that supports any platform that wants to opt in
Custom Visual Studio project generation logic that supports any platform that has a msvs.py
script, so Visual Studio can be used to run scons for any platform, with the right defines per target.
Invoked with `scons vsproj=yes`
To generate build configuration files for all platforms+targets+arch combinations, users should call
```
scons vsproj=yes platform=XXX target=YYY [other build flags]
```
for each combination of platform+target[+arch]. This will generate the relevant vs project files but
skip the build process, so that project files can be quickly generated without waiting for a command line
build. This lets project files be quickly generated even if there are build errors.
All possible combinations of platform+target are created in the solution file by default, but they
won't do anything until each one is set up with a scons vsproj=yes command for the respective platform
in the appropriate command line. This lets users only generate the combinations they need, and VS
won't have to parse settings for other combos.
Only platforms that opt in to vs proj generation by having a msvs.py file in the platform folder are included.
Platforms with a msvs.py file will be added to the solution, but only the current active platform+target+arch
will have a build configuration generated, because we only know what the right defines/includes/flags/etc are
on the active build target currently being processed by scons.
Platforms that don't support an editor target will have a dummy editor target that won't do anything on build,
but will have the files and configuration for the windows editor target.
To generate AND build from the command line, run
```
scons vsproj=yes vsproj_gen_only=no
```
2023-11-14 20:39:44 +08:00
|
|
|
all_items.append(f'<None Include="{file}">')
|
|
|
|
all_items.append(
|
2024-02-15 20:06:34 +08:00
|
|
|
f" <ExcludedFromBuild Condition=\"!$(ActiveProjectItemList_{base_path}.Contains(';{file};'))\">true</ExcludedFromBuild>"
|
Add new VS proj generation logic that supports any platform that wants to opt in
Custom Visual Studio project generation logic that supports any platform that has a msvs.py
script, so Visual Studio can be used to run scons for any platform, with the right defines per target.
Invoked with `scons vsproj=yes`
To generate build configuration files for all platforms+targets+arch combinations, users should call
```
scons vsproj=yes platform=XXX target=YYY [other build flags]
```
for each combination of platform+target[+arch]. This will generate the relevant vs project files but
skip the build process, so that project files can be quickly generated without waiting for a command line
build. This lets project files be quickly generated even if there are build errors.
All possible combinations of platform+target are created in the solution file by default, but they
won't do anything until each one is set up with a scons vsproj=yes command for the respective platform
in the appropriate command line. This lets users only generate the combinations they need, and VS
won't have to parse settings for other combos.
Only platforms that opt in to vs proj generation by having a msvs.py file in the platform folder are included.
Platforms with a msvs.py file will be added to the solution, but only the current active platform+target+arch
will have a build configuration generated, because we only know what the right defines/includes/flags/etc are
on the active build target currently being processed by scons.
Platforms that don't support an editor target will have a dummy editor target that won't do anything on build,
but will have the files and configuration for the windows editor target.
To generate AND build from the command line, run
```
scons vsproj=yes vsproj_gen_only=no
```
2023-11-14 20:39:44 +08:00
|
|
|
)
|
|
|
|
all_items.append("</None>")
|
|
|
|
if file in set_others:
|
|
|
|
activeItems.append(file)
|
|
|
|
|
|
|
|
if vs_configuration:
|
|
|
|
vsconf = ""
|
|
|
|
for a in vs_configuration["arches"]:
|
|
|
|
if arch == a["architecture"]:
|
|
|
|
vsconf = f'{target}|{a["platform"]}'
|
|
|
|
break
|
|
|
|
|
2024-02-12 23:39:58 +08:00
|
|
|
condition = "'$(GodotConfiguration)|$(GodotPlatform)'=='" + vsconf + "'"
|
2024-02-15 20:06:34 +08:00
|
|
|
itemlist = {}
|
|
|
|
for item in activeItems:
|
|
|
|
key = os.path.dirname(item).replace("\\", "_")
|
2024-05-21 21:14:59 +08:00
|
|
|
if key not in itemlist:
|
2024-02-15 20:06:34 +08:00
|
|
|
itemlist[key] = [item]
|
|
|
|
else:
|
|
|
|
itemlist[key] += [item]
|
|
|
|
|
|
|
|
for x in itemlist.keys():
|
|
|
|
properties.append(
|
|
|
|
"<ActiveProjectItemList_%s>;%s;</ActiveProjectItemList_%s>" % (x, ";".join(itemlist[x]), x)
|
|
|
|
)
|
Add new VS proj generation logic that supports any platform that wants to opt in
Custom Visual Studio project generation logic that supports any platform that has a msvs.py
script, so Visual Studio can be used to run scons for any platform, with the right defines per target.
Invoked with `scons vsproj=yes`
To generate build configuration files for all platforms+targets+arch combinations, users should call
```
scons vsproj=yes platform=XXX target=YYY [other build flags]
```
for each combination of platform+target[+arch]. This will generate the relevant vs project files but
skip the build process, so that project files can be quickly generated without waiting for a command line
build. This lets project files be quickly generated even if there are build errors.
All possible combinations of platform+target are created in the solution file by default, but they
won't do anything until each one is set up with a scons vsproj=yes command for the respective platform
in the appropriate command line. This lets users only generate the combinations they need, and VS
won't have to parse settings for other combos.
Only platforms that opt in to vs proj generation by having a msvs.py file in the platform folder are included.
Platforms with a msvs.py file will be added to the solution, but only the current active platform+target+arch
will have a build configuration generated, because we only know what the right defines/includes/flags/etc are
on the active build target currently being processed by scons.
Platforms that don't support an editor target will have a dummy editor target that won't do anything on build,
but will have the files and configuration for the windows editor target.
To generate AND build from the command line, run
```
scons vsproj=yes vsproj_gen_only=no
```
2023-11-14 20:39:44 +08:00
|
|
|
output = f'bin\\godot{env["PROGSUFFIX"]}'
|
|
|
|
|
2024-03-25 01:02:56 +08:00
|
|
|
with open("misc/msvs/props.template", "r", encoding="utf-8") as file:
|
2024-03-11 01:09:48 +08:00
|
|
|
props_template = file.read()
|
Add new VS proj generation logic that supports any platform that wants to opt in
Custom Visual Studio project generation logic that supports any platform that has a msvs.py
script, so Visual Studio can be used to run scons for any platform, with the right defines per target.
Invoked with `scons vsproj=yes`
To generate build configuration files for all platforms+targets+arch combinations, users should call
```
scons vsproj=yes platform=XXX target=YYY [other build flags]
```
for each combination of platform+target[+arch]. This will generate the relevant vs project files but
skip the build process, so that project files can be quickly generated without waiting for a command line
build. This lets project files be quickly generated even if there are build errors.
All possible combinations of platform+target are created in the solution file by default, but they
won't do anything until each one is set up with a scons vsproj=yes command for the respective platform
in the appropriate command line. This lets users only generate the combinations they need, and VS
won't have to parse settings for other combos.
Only platforms that opt in to vs proj generation by having a msvs.py file in the platform folder are included.
Platforms with a msvs.py file will be added to the solution, but only the current active platform+target+arch
will have a build configuration generated, because we only know what the right defines/includes/flags/etc are
on the active build target currently being processed by scons.
Platforms that don't support an editor target will have a dummy editor target that won't do anything on build,
but will have the files and configuration for the windows editor target.
To generate AND build from the command line, run
```
scons vsproj=yes vsproj_gen_only=no
```
2023-11-14 20:39:44 +08:00
|
|
|
|
|
|
|
props_template = props_template.replace("%%VSCONF%%", vsconf)
|
|
|
|
props_template = props_template.replace("%%CONDITION%%", condition)
|
|
|
|
props_template = props_template.replace("%%PROPERTIES%%", "\n ".join(properties))
|
|
|
|
props_template = props_template.replace("%%EXTRA_ITEMS%%", "\n ".join(extraItems))
|
|
|
|
|
|
|
|
props_template = props_template.replace("%%OUTPUT%%", output)
|
|
|
|
|
2024-02-12 20:28:35 +08:00
|
|
|
proplist = [format_key_value(v) for v in list(env["CPPDEFINES"])]
|
|
|
|
proplist += [format_key_value(j) for j in env.get("VSHINT_DEFINES", [])]
|
|
|
|
props_template = props_template.replace("%%DEFINES%%", ";".join(proplist))
|
|
|
|
|
|
|
|
proplist = [str(j) for j in env["CPPPATH"]]
|
|
|
|
proplist += [str(j) for j in env.get("VSHINT_INCLUDES", [])]
|
|
|
|
props_template = props_template.replace("%%INCLUDES%%", ";".join(proplist))
|
|
|
|
|
|
|
|
proplist = env["CCFLAGS"]
|
|
|
|
proplist += [x for x in env["CXXFLAGS"] if not x.startswith("$")]
|
|
|
|
proplist += [str(j) for j in env.get("VSHINT_OPTIONS", [])]
|
|
|
|
props_template = props_template.replace("%%OPTIONS%%", " ".join(proplist))
|
Add new VS proj generation logic that supports any platform that wants to opt in
Custom Visual Studio project generation logic that supports any platform that has a msvs.py
script, so Visual Studio can be used to run scons for any platform, with the right defines per target.
Invoked with `scons vsproj=yes`
To generate build configuration files for all platforms+targets+arch combinations, users should call
```
scons vsproj=yes platform=XXX target=YYY [other build flags]
```
for each combination of platform+target[+arch]. This will generate the relevant vs project files but
skip the build process, so that project files can be quickly generated without waiting for a command line
build. This lets project files be quickly generated even if there are build errors.
All possible combinations of platform+target are created in the solution file by default, but they
won't do anything until each one is set up with a scons vsproj=yes command for the respective platform
in the appropriate command line. This lets users only generate the combinations they need, and VS
won't have to parse settings for other combos.
Only platforms that opt in to vs proj generation by having a msvs.py file in the platform folder are included.
Platforms with a msvs.py file will be added to the solution, but only the current active platform+target+arch
will have a build configuration generated, because we only know what the right defines/includes/flags/etc are
on the active build target currently being processed by scons.
Platforms that don't support an editor target will have a dummy editor target that won't do anything on build,
but will have the files and configuration for the windows editor target.
To generate AND build from the command line, run
```
scons vsproj=yes vsproj_gen_only=no
```
2023-11-14 20:39:44 +08:00
|
|
|
|
|
|
|
# Windows allows us to have spaces in paths, so we need
|
|
|
|
# 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
|
|
|
|
common_build_postfix = [
|
|
|
|
"--directory="$(ProjectDir.TrimEnd('\\'))"",
|
|
|
|
"progress=no",
|
|
|
|
f"platform={platform}",
|
|
|
|
f"target={target}",
|
|
|
|
f"arch={arch}",
|
|
|
|
]
|
|
|
|
|
|
|
|
for arg, value in filtered_args.items():
|
|
|
|
common_build_postfix.append(f"{arg}={value}")
|
|
|
|
|
|
|
|
cmd_rebuild = [
|
|
|
|
"vsproj=yes",
|
2024-02-15 20:06:34 +08:00
|
|
|
"vsproj_props_only=yes",
|
|
|
|
"vsproj_gen_only=no",
|
Add new VS proj generation logic that supports any platform that wants to opt in
Custom Visual Studio project generation logic that supports any platform that has a msvs.py
script, so Visual Studio can be used to run scons for any platform, with the right defines per target.
Invoked with `scons vsproj=yes`
To generate build configuration files for all platforms+targets+arch combinations, users should call
```
scons vsproj=yes platform=XXX target=YYY [other build flags]
```
for each combination of platform+target[+arch]. This will generate the relevant vs project files but
skip the build process, so that project files can be quickly generated without waiting for a command line
build. This lets project files be quickly generated even if there are build errors.
All possible combinations of platform+target are created in the solution file by default, but they
won't do anything until each one is set up with a scons vsproj=yes command for the respective platform
in the appropriate command line. This lets users only generate the combinations they need, and VS
won't have to parse settings for other combos.
Only platforms that opt in to vs proj generation by having a msvs.py file in the platform folder are included.
Platforms with a msvs.py file will be added to the solution, but only the current active platform+target+arch
will have a build configuration generated, because we only know what the right defines/includes/flags/etc are
on the active build target currently being processed by scons.
Platforms that don't support an editor target will have a dummy editor target that won't do anything on build,
but will have the files and configuration for the windows editor target.
To generate AND build from the command line, run
```
scons vsproj=yes vsproj_gen_only=no
```
2023-11-14 20:39:44 +08:00
|
|
|
f"vsproj_name={project_name}",
|
|
|
|
] + common_build_postfix
|
|
|
|
|
|
|
|
cmd_clean = [
|
|
|
|
"--clean",
|
|
|
|
] + common_build_postfix
|
|
|
|
|
|
|
|
commands = "scons"
|
|
|
|
if len(common_build_prefix) == 0:
|
|
|
|
commands = "echo Starting SCons && cmd /V /C " + commands
|
|
|
|
else:
|
|
|
|
common_build_prefix[0] = "echo Starting SCons && cmd /V /C " + common_build_prefix[0]
|
|
|
|
|
|
|
|
cmd = " ^& ".join(common_build_prefix + [" ".join([commands] + common_build_postfix)])
|
|
|
|
props_template = props_template.replace("%%BUILD%%", cmd)
|
|
|
|
|
|
|
|
cmd = " ^& ".join(common_build_prefix + [" ".join([commands] + cmd_rebuild)])
|
|
|
|
props_template = props_template.replace("%%REBUILD%%", cmd)
|
|
|
|
|
|
|
|
cmd = " ^& ".join(common_build_prefix + [" ".join([commands] + cmd_clean)])
|
|
|
|
props_template = props_template.replace("%%CLEAN%%", cmd)
|
|
|
|
|
2024-03-10 04:29:24 +08:00
|
|
|
with open(
|
2024-04-10 22:59:57 +08:00
|
|
|
f"{project_name}.{platform}.{target}.{arch}.generated.props", "w", encoding="utf-8", newline="\r\n"
|
2024-03-10 04:29:24 +08:00
|
|
|
) as f:
|
Add new VS proj generation logic that supports any platform that wants to opt in
Custom Visual Studio project generation logic that supports any platform that has a msvs.py
script, so Visual Studio can be used to run scons for any platform, with the right defines per target.
Invoked with `scons vsproj=yes`
To generate build configuration files for all platforms+targets+arch combinations, users should call
```
scons vsproj=yes platform=XXX target=YYY [other build flags]
```
for each combination of platform+target[+arch]. This will generate the relevant vs project files but
skip the build process, so that project files can be quickly generated without waiting for a command line
build. This lets project files be quickly generated even if there are build errors.
All possible combinations of platform+target are created in the solution file by default, but they
won't do anything until each one is set up with a scons vsproj=yes command for the respective platform
in the appropriate command line. This lets users only generate the combinations they need, and VS
won't have to parse settings for other combos.
Only platforms that opt in to vs proj generation by having a msvs.py file in the platform folder are included.
Platforms with a msvs.py file will be added to the solution, but only the current active platform+target+arch
will have a build configuration generated, because we only know what the right defines/includes/flags/etc are
on the active build target currently being processed by scons.
Platforms that don't support an editor target will have a dummy editor target that won't do anything on build,
but will have the files and configuration for the windows editor target.
To generate AND build from the command line, run
```
scons vsproj=yes vsproj_gen_only=no
```
2023-11-14 20:39:44 +08:00
|
|
|
f.write(props_template)
|
|
|
|
|
|
|
|
proj_uuid = str(uuid.uuid4())
|
|
|
|
sln_uuid = str(uuid.uuid4())
|
|
|
|
|
|
|
|
if os.path.exists(f"{project_name}.sln"):
|
2024-03-25 01:02:56 +08:00
|
|
|
for line in open(f"{project_name}.sln", "r", encoding="utf-8").read().splitlines():
|
Add new VS proj generation logic that supports any platform that wants to opt in
Custom Visual Studio project generation logic that supports any platform that has a msvs.py
script, so Visual Studio can be used to run scons for any platform, with the right defines per target.
Invoked with `scons vsproj=yes`
To generate build configuration files for all platforms+targets+arch combinations, users should call
```
scons vsproj=yes platform=XXX target=YYY [other build flags]
```
for each combination of platform+target[+arch]. This will generate the relevant vs project files but
skip the build process, so that project files can be quickly generated without waiting for a command line
build. This lets project files be quickly generated even if there are build errors.
All possible combinations of platform+target are created in the solution file by default, but they
won't do anything until each one is set up with a scons vsproj=yes command for the respective platform
in the appropriate command line. This lets users only generate the combinations they need, and VS
won't have to parse settings for other combos.
Only platforms that opt in to vs proj generation by having a msvs.py file in the platform folder are included.
Platforms with a msvs.py file will be added to the solution, but only the current active platform+target+arch
will have a build configuration generated, because we only know what the right defines/includes/flags/etc are
on the active build target currently being processed by scons.
Platforms that don't support an editor target will have a dummy editor target that won't do anything on build,
but will have the files and configuration for the windows editor target.
To generate AND build from the command line, run
```
scons vsproj=yes vsproj_gen_only=no
```
2023-11-14 20:39:44 +08:00
|
|
|
if line.startswith('Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}")'):
|
|
|
|
proj_uuid = re.search(
|
|
|
|
r"\"{(\b[0-9a-fA-F]{8}\b-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-\b[0-9a-fA-F]{12}\b)}\"$",
|
|
|
|
line,
|
|
|
|
).group(1)
|
|
|
|
elif line.strip().startswith("SolutionGuid ="):
|
|
|
|
sln_uuid = re.search(
|
|
|
|
r"{(\b[0-9a-fA-F]{8}\b-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-\b[0-9a-fA-F]{12}\b)}", line
|
|
|
|
).group(1)
|
|
|
|
break
|
|
|
|
|
|
|
|
configurations = []
|
|
|
|
imports = []
|
|
|
|
properties = []
|
|
|
|
section1 = []
|
|
|
|
section2 = []
|
|
|
|
for conf in confs:
|
|
|
|
godot_platform = conf["platform"]
|
|
|
|
for p in conf["arches"]:
|
|
|
|
sln_plat = p["platform"]
|
|
|
|
proj_plat = sln_plat
|
|
|
|
godot_arch = p["architecture"]
|
|
|
|
|
|
|
|
# Redirect editor configurations for non-Windows platforms to the Windows one, so the solution has all the permutations
|
|
|
|
# and VS doesn't complain about missing project configurations.
|
|
|
|
# These configurations are disabled, so they show up but won't build.
|
|
|
|
if godot_platform != "windows":
|
|
|
|
section1 += [f"editor|{sln_plat} = editor|{proj_plat}"]
|
|
|
|
section2 += [
|
|
|
|
f"{{{proj_uuid}}}.editor|{proj_plat}.ActiveCfg = editor|{proj_plat}",
|
|
|
|
]
|
|
|
|
|
|
|
|
for t in conf["targets"]:
|
|
|
|
godot_target = t
|
|
|
|
|
|
|
|
# Windows x86 is a special little flower that requires a project platform == Win32 but a solution platform == x86.
|
|
|
|
if godot_platform == "windows" and godot_target == "editor" and godot_arch == "x86_32":
|
|
|
|
sln_plat = "x86"
|
|
|
|
|
|
|
|
configurations += [
|
|
|
|
f'<ProjectConfiguration Include="{godot_target}|{proj_plat}">',
|
|
|
|
f" <Configuration>{godot_target}</Configuration>",
|
|
|
|
f" <Platform>{proj_plat}</Platform>",
|
|
|
|
"</ProjectConfiguration>",
|
|
|
|
]
|
|
|
|
|
2024-02-12 23:39:58 +08:00
|
|
|
properties += [
|
|
|
|
f"<PropertyGroup Condition=\"'$(Configuration)|$(Platform)'=='{godot_target}|{proj_plat}'\">",
|
|
|
|
f" <GodotConfiguration>{godot_target}</GodotConfiguration>",
|
|
|
|
f" <GodotPlatform>{proj_plat}</GodotPlatform>",
|
|
|
|
"</PropertyGroup>",
|
|
|
|
]
|
|
|
|
|
Add new VS proj generation logic that supports any platform that wants to opt in
Custom Visual Studio project generation logic that supports any platform that has a msvs.py
script, so Visual Studio can be used to run scons for any platform, with the right defines per target.
Invoked with `scons vsproj=yes`
To generate build configuration files for all platforms+targets+arch combinations, users should call
```
scons vsproj=yes platform=XXX target=YYY [other build flags]
```
for each combination of platform+target[+arch]. This will generate the relevant vs project files but
skip the build process, so that project files can be quickly generated without waiting for a command line
build. This lets project files be quickly generated even if there are build errors.
All possible combinations of platform+target are created in the solution file by default, but they
won't do anything until each one is set up with a scons vsproj=yes command for the respective platform
in the appropriate command line. This lets users only generate the combinations they need, and VS
won't have to parse settings for other combos.
Only platforms that opt in to vs proj generation by having a msvs.py file in the platform folder are included.
Platforms with a msvs.py file will be added to the solution, but only the current active platform+target+arch
will have a build configuration generated, because we only know what the right defines/includes/flags/etc are
on the active build target currently being processed by scons.
Platforms that don't support an editor target will have a dummy editor target that won't do anything on build,
but will have the files and configuration for the windows editor target.
To generate AND build from the command line, run
```
scons vsproj=yes vsproj_gen_only=no
```
2023-11-14 20:39:44 +08:00
|
|
|
if godot_platform != "windows":
|
|
|
|
configurations += [
|
|
|
|
f'<ProjectConfiguration Include="editor|{proj_plat}">',
|
2024-05-21 21:14:59 +08:00
|
|
|
" <Configuration>editor</Configuration>",
|
Add new VS proj generation logic that supports any platform that wants to opt in
Custom Visual Studio project generation logic that supports any platform that has a msvs.py
script, so Visual Studio can be used to run scons for any platform, with the right defines per target.
Invoked with `scons vsproj=yes`
To generate build configuration files for all platforms+targets+arch combinations, users should call
```
scons vsproj=yes platform=XXX target=YYY [other build flags]
```
for each combination of platform+target[+arch]. This will generate the relevant vs project files but
skip the build process, so that project files can be quickly generated without waiting for a command line
build. This lets project files be quickly generated even if there are build errors.
All possible combinations of platform+target are created in the solution file by default, but they
won't do anything until each one is set up with a scons vsproj=yes command for the respective platform
in the appropriate command line. This lets users only generate the combinations they need, and VS
won't have to parse settings for other combos.
Only platforms that opt in to vs proj generation by having a msvs.py file in the platform folder are included.
Platforms with a msvs.py file will be added to the solution, but only the current active platform+target+arch
will have a build configuration generated, because we only know what the right defines/includes/flags/etc are
on the active build target currently being processed by scons.
Platforms that don't support an editor target will have a dummy editor target that won't do anything on build,
but will have the files and configuration for the windows editor target.
To generate AND build from the command line, run
```
scons vsproj=yes vsproj_gen_only=no
```
2023-11-14 20:39:44 +08:00
|
|
|
f" <Platform>{proj_plat}</Platform>",
|
|
|
|
"</ProjectConfiguration>",
|
|
|
|
]
|
|
|
|
|
2024-02-12 23:39:58 +08:00
|
|
|
properties += [
|
|
|
|
f"<PropertyGroup Condition=\"'$(Configuration)|$(Platform)'=='editor|{proj_plat}'\">",
|
2024-05-21 21:14:59 +08:00
|
|
|
" <GodotConfiguration>editor</GodotConfiguration>",
|
2024-02-12 23:39:58 +08:00
|
|
|
f" <GodotPlatform>{proj_plat}</GodotPlatform>",
|
|
|
|
"</PropertyGroup>",
|
|
|
|
]
|
|
|
|
|
Add new VS proj generation logic that supports any platform that wants to opt in
Custom Visual Studio project generation logic that supports any platform that has a msvs.py
script, so Visual Studio can be used to run scons for any platform, with the right defines per target.
Invoked with `scons vsproj=yes`
To generate build configuration files for all platforms+targets+arch combinations, users should call
```
scons vsproj=yes platform=XXX target=YYY [other build flags]
```
for each combination of platform+target[+arch]. This will generate the relevant vs project files but
skip the build process, so that project files can be quickly generated without waiting for a command line
build. This lets project files be quickly generated even if there are build errors.
All possible combinations of platform+target are created in the solution file by default, but they
won't do anything until each one is set up with a scons vsproj=yes command for the respective platform
in the appropriate command line. This lets users only generate the combinations they need, and VS
won't have to parse settings for other combos.
Only platforms that opt in to vs proj generation by having a msvs.py file in the platform folder are included.
Platforms with a msvs.py file will be added to the solution, but only the current active platform+target+arch
will have a build configuration generated, because we only know what the right defines/includes/flags/etc are
on the active build target currently being processed by scons.
Platforms that don't support an editor target will have a dummy editor target that won't do anything on build,
but will have the files and configuration for the windows editor target.
To generate AND build from the command line, run
```
scons vsproj=yes vsproj_gen_only=no
```
2023-11-14 20:39:44 +08:00
|
|
|
p = f"{project_name}.{godot_platform}.{godot_target}.{godot_arch}.generated.props"
|
|
|
|
imports += [
|
|
|
|
f'<Import Project="$(MSBuildProjectDirectory)\\{p}" Condition="Exists(\'$(MSBuildProjectDirectory)\\{p}\')"/>'
|
|
|
|
]
|
|
|
|
|
|
|
|
section1 += [f"{godot_target}|{sln_plat} = {godot_target}|{sln_plat}"]
|
|
|
|
|
|
|
|
section2 += [
|
|
|
|
f"{{{proj_uuid}}}.{godot_target}|{sln_plat}.ActiveCfg = {godot_target}|{proj_plat}",
|
|
|
|
f"{{{proj_uuid}}}.{godot_target}|{sln_plat}.Build.0 = {godot_target}|{proj_plat}",
|
|
|
|
]
|
|
|
|
|
2024-02-12 23:39:58 +08:00
|
|
|
# Add an extra import for a local user props file at the end, so users can add more overrides.
|
|
|
|
imports += [
|
|
|
|
f'<Import Project="$(MSBuildProjectDirectory)\\{project_name}.vs.user.props" Condition="Exists(\'$(MSBuildProjectDirectory)\\{project_name}.vs.user.props\')"/>'
|
|
|
|
]
|
Add new VS proj generation logic that supports any platform that wants to opt in
Custom Visual Studio project generation logic that supports any platform that has a msvs.py
script, so Visual Studio can be used to run scons for any platform, with the right defines per target.
Invoked with `scons vsproj=yes`
To generate build configuration files for all platforms+targets+arch combinations, users should call
```
scons vsproj=yes platform=XXX target=YYY [other build flags]
```
for each combination of platform+target[+arch]. This will generate the relevant vs project files but
skip the build process, so that project files can be quickly generated without waiting for a command line
build. This lets project files be quickly generated even if there are build errors.
All possible combinations of platform+target are created in the solution file by default, but they
won't do anything until each one is set up with a scons vsproj=yes command for the respective platform
in the appropriate command line. This lets users only generate the combinations they need, and VS
won't have to parse settings for other combos.
Only platforms that opt in to vs proj generation by having a msvs.py file in the platform folder are included.
Platforms with a msvs.py file will be added to the solution, but only the current active platform+target+arch
will have a build configuration generated, because we only know what the right defines/includes/flags/etc are
on the active build target currently being processed by scons.
Platforms that don't support an editor target will have a dummy editor target that won't do anything on build,
but will have the files and configuration for the windows editor target.
To generate AND build from the command line, run
```
scons vsproj=yes vsproj_gen_only=no
```
2023-11-14 20:39:44 +08:00
|
|
|
section1 = sorted(section1)
|
|
|
|
section2 = sorted(section2)
|
|
|
|
|
2024-02-15 20:06:34 +08:00
|
|
|
if not get_bool(original_args, "vsproj_props_only", False):
|
2024-03-25 01:02:56 +08:00
|
|
|
with open("misc/msvs/vcxproj.template", "r", encoding="utf-8") as file:
|
2024-03-11 01:09:48 +08:00
|
|
|
proj_template = file.read()
|
2024-02-15 20:06:34 +08:00
|
|
|
proj_template = proj_template.replace("%%UUID%%", proj_uuid)
|
|
|
|
proj_template = proj_template.replace("%%CONFS%%", "\n ".join(configurations))
|
|
|
|
proj_template = proj_template.replace("%%IMPORTS%%", "\n ".join(imports))
|
|
|
|
proj_template = proj_template.replace("%%DEFAULT_ITEMS%%", "\n ".join(all_items))
|
|
|
|
proj_template = proj_template.replace("%%PROPERTIES%%", "\n ".join(properties))
|
|
|
|
|
2024-06-30 01:55:09 +08:00
|
|
|
with open(f"{project_name}.vcxproj", "w", encoding="utf-8", newline="\r\n") as f:
|
2024-02-15 20:06:34 +08:00
|
|
|
f.write(proj_template)
|
|
|
|
|
|
|
|
if not get_bool(original_args, "vsproj_props_only", False):
|
2024-03-25 01:02:56 +08:00
|
|
|
with open("misc/msvs/sln.template", "r", encoding="utf-8") as file:
|
2024-03-11 01:09:48 +08:00
|
|
|
sln_template = file.read()
|
2024-02-15 20:06:34 +08:00
|
|
|
sln_template = sln_template.replace("%%NAME%%", project_name)
|
|
|
|
sln_template = sln_template.replace("%%UUID%%", proj_uuid)
|
|
|
|
sln_template = sln_template.replace("%%SLNUUID%%", sln_uuid)
|
2024-04-12 22:04:35 +08:00
|
|
|
sln_template = sln_template.replace("%%SECTION1%%", "\n\t\t".join(section1))
|
|
|
|
sln_template = sln_template.replace("%%SECTION2%%", "\n\t\t".join(section2))
|
2024-02-15 20:06:34 +08:00
|
|
|
|
2024-04-10 22:59:57 +08:00
|
|
|
with open(f"{project_name}.sln", "w", encoding="utf-8", newline="\r\n") as f:
|
2024-02-15 20:06:34 +08:00
|
|
|
f.write(sln_template)
|
Add new VS proj generation logic that supports any platform that wants to opt in
Custom Visual Studio project generation logic that supports any platform that has a msvs.py
script, so Visual Studio can be used to run scons for any platform, with the right defines per target.
Invoked with `scons vsproj=yes`
To generate build configuration files for all platforms+targets+arch combinations, users should call
```
scons vsproj=yes platform=XXX target=YYY [other build flags]
```
for each combination of platform+target[+arch]. This will generate the relevant vs project files but
skip the build process, so that project files can be quickly generated without waiting for a command line
build. This lets project files be quickly generated even if there are build errors.
All possible combinations of platform+target are created in the solution file by default, but they
won't do anything until each one is set up with a scons vsproj=yes command for the respective platform
in the appropriate command line. This lets users only generate the combinations they need, and VS
won't have to parse settings for other combos.
Only platforms that opt in to vs proj generation by having a msvs.py file in the platform folder are included.
Platforms with a msvs.py file will be added to the solution, but only the current active platform+target+arch
will have a build configuration generated, because we only know what the right defines/includes/flags/etc are
on the active build target currently being processed by scons.
Platforms that don't support an editor target will have a dummy editor target that won't do anything on build,
but will have the files and configuration for the windows editor target.
To generate AND build from the command line, run
```
scons vsproj=yes vsproj_gen_only=no
```
2023-11-14 20:39:44 +08:00
|
|
|
|
|
|
|
if get_bool(original_args, "vsproj_gen_only", True):
|
|
|
|
sys.exit()
|
2024-05-03 22:44:57 +08:00
|
|
|
|
|
|
|
|
|
|
|
def generate_copyright_header(filename: str) -> str:
|
|
|
|
MARGIN = 70
|
|
|
|
TEMPLATE = """\
|
|
|
|
/**************************************************************************/
|
|
|
|
/* %s*/
|
|
|
|
/**************************************************************************/
|
|
|
|
/* This file is part of: */
|
|
|
|
/* GODOT ENGINE */
|
|
|
|
/* https://godotengine.org */
|
|
|
|
/**************************************************************************/
|
|
|
|
/* Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md). */
|
|
|
|
/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur. */
|
|
|
|
/* */
|
|
|
|
/* Permission is hereby granted, free of charge, to any person obtaining */
|
|
|
|
/* a copy of this software and associated documentation files (the */
|
|
|
|
/* "Software"), to deal in the Software without restriction, including */
|
|
|
|
/* without limitation the rights to use, copy, modify, merge, publish, */
|
|
|
|
/* distribute, sublicense, and/or sell copies of the Software, and to */
|
|
|
|
/* permit persons to whom the Software is furnished to do so, subject to */
|
|
|
|
/* the following conditions: */
|
|
|
|
/* */
|
|
|
|
/* The above copyright notice and this permission notice shall be */
|
|
|
|
/* included in all copies or substantial portions of the Software. */
|
|
|
|
/* */
|
|
|
|
/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */
|
|
|
|
/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */
|
|
|
|
/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. */
|
|
|
|
/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */
|
|
|
|
/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */
|
|
|
|
/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */
|
|
|
|
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
|
|
|
|
/**************************************************************************/
|
|
|
|
"""
|
|
|
|
filename = filename.split("/")[-1].ljust(MARGIN)
|
|
|
|
if len(filename) > MARGIN:
|
|
|
|
print(f'WARNING: Filename "{filename}" too large for copyright header.')
|
|
|
|
return TEMPLATE % filename
|
|
|
|
|
|
|
|
|
|
|
|
@contextlib.contextmanager
|
|
|
|
def generated_wrapper(
|
|
|
|
path, # FIXME: type with `Union[str, Node, List[Node]]` when pytest conflicts are resolved
|
|
|
|
guard: Optional[bool] = None,
|
|
|
|
prefix: str = "",
|
|
|
|
suffix: str = "",
|
|
|
|
) -> Generator[TextIOWrapper, None, None]:
|
|
|
|
"""
|
|
|
|
Wrapper class to automatically handle copyright headers and header guards
|
|
|
|
for generated scripts. Meant to be invoked via `with` statement similar to
|
|
|
|
creating a file.
|
|
|
|
|
|
|
|
- `path`: The path of the file to be created. Can be passed a raw string, an
|
|
|
|
isolated SCons target, or a full SCons target list. If a target list contains
|
|
|
|
multiple entries, produces a warning & only creates the first entry.
|
|
|
|
- `guard`: Optional bool to determine if a header guard should be added. If
|
|
|
|
unassigned, header guards are determined by the file extension.
|
|
|
|
- `prefix`: Custom prefix to prepend to a header guard. Produces a warning if
|
|
|
|
provided a value when `guard` evaluates to `False`.
|
|
|
|
- `suffix`: Custom suffix to append to a header guard. Produces a warning if
|
|
|
|
provided a value when `guard` evaluates to `False`.
|
|
|
|
"""
|
|
|
|
|
|
|
|
# Handle unfiltered SCons target[s] passed as path.
|
|
|
|
if not isinstance(path, str):
|
|
|
|
if isinstance(path, list):
|
|
|
|
if len(path) > 1:
|
|
|
|
print_warning(
|
|
|
|
"Attempting to use generated wrapper with multiple targets; "
|
|
|
|
f"will only use first entry: {path[0]}"
|
|
|
|
)
|
|
|
|
path = path[0]
|
|
|
|
if not hasattr(path, "get_abspath"):
|
|
|
|
raise TypeError(f'Expected type "str", "Node" or "List[Node]"; was passed {type(path)}.')
|
|
|
|
path = path.get_abspath()
|
|
|
|
|
|
|
|
path = str(path).replace("\\", "/")
|
|
|
|
if guard is None:
|
|
|
|
guard = path.endswith((".h", ".hh", ".hpp", ".inc"))
|
|
|
|
if not guard and (prefix or suffix):
|
|
|
|
print_warning(f'Trying to assign header guard prefix/suffix while `guard` is disabled: "{path}".')
|
|
|
|
|
|
|
|
header_guard = ""
|
|
|
|
if guard:
|
|
|
|
if prefix:
|
|
|
|
prefix += "_"
|
|
|
|
if suffix:
|
|
|
|
suffix = f"_{suffix}"
|
|
|
|
split = path.split("/")[-1].split(".")
|
|
|
|
header_guard = (f"{prefix}{split[0]}{suffix}.{'.'.join(split[1:])}".upper()
|
|
|
|
.replace(".", "_").replace("-", "_").replace(" ", "_").replace("__", "_")) # fmt: skip
|
|
|
|
|
|
|
|
with open(path, "wt", encoding="utf-8", newline="\n") as file:
|
|
|
|
file.write(generate_copyright_header(path))
|
|
|
|
file.write("\n/* THIS FILE IS GENERATED. EDITS WILL BE LOST. */\n\n")
|
|
|
|
|
|
|
|
if guard:
|
|
|
|
file.write(f"#ifndef {header_guard}\n")
|
|
|
|
file.write(f"#define {header_guard}\n\n")
|
|
|
|
|
|
|
|
with StringIO(newline="\n") as str_io:
|
|
|
|
yield str_io
|
|
|
|
file.write(str_io.getvalue().strip() or "/* NO CONTENT */")
|
|
|
|
|
|
|
|
if guard:
|
|
|
|
file.write(f"\n\n#endif // {header_guard}")
|
|
|
|
|
|
|
|
file.write("\n")
|
2024-08-01 03:15:56 +08:00
|
|
|
|
|
|
|
|
|
|
|
def to_raw_cstring(value: Union[str, List[str]]) -> str:
|
|
|
|
MAX_LITERAL = 16 * 1024
|
|
|
|
|
|
|
|
if isinstance(value, list):
|
|
|
|
value = "\n".join(value) + "\n"
|
|
|
|
|
|
|
|
split: List[bytes] = []
|
|
|
|
offset = 0
|
|
|
|
encoded = value.encode()
|
|
|
|
|
|
|
|
while offset <= len(encoded):
|
|
|
|
segment = encoded[offset : offset + MAX_LITERAL]
|
|
|
|
offset += MAX_LITERAL
|
|
|
|
if len(segment) == MAX_LITERAL:
|
|
|
|
# Try to segment raw strings at double newlines to keep readable.
|
|
|
|
pretty_break = segment.rfind(b"\n\n")
|
|
|
|
if pretty_break != -1:
|
|
|
|
segment = segment[: pretty_break + 1]
|
|
|
|
offset -= MAX_LITERAL - pretty_break - 1
|
|
|
|
# If none found, ensure we end with valid utf8.
|
|
|
|
# https://github.com/halloleo/unicut/blob/master/truncate.py
|
|
|
|
elif segment[-1] & 0b10000000:
|
|
|
|
last_11xxxxxx_index = [i for i in range(-1, -5, -1) if segment[i] & 0b11000000 == 0b11000000][0]
|
|
|
|
last_11xxxxxx = segment[last_11xxxxxx_index]
|
|
|
|
if not last_11xxxxxx & 0b00100000:
|
|
|
|
last_char_length = 2
|
|
|
|
elif not last_11xxxxxx & 0b0010000:
|
|
|
|
last_char_length = 3
|
|
|
|
elif not last_11xxxxxx & 0b0001000:
|
|
|
|
last_char_length = 4
|
|
|
|
|
|
|
|
if last_char_length > -last_11xxxxxx_index:
|
|
|
|
segment = segment[:last_11xxxxxx_index]
|
|
|
|
offset += last_11xxxxxx_index
|
|
|
|
|
|
|
|
split += [segment]
|
|
|
|
|
|
|
|
return " ".join(f'R"<!>({x.decode()})<!>"' for x in split)
|