#!/usr/bin/env python import json import re import shutil from pathlib import Path def generate_mod_version(argcount, const=False, returns=False): s = """ #define MODBIND$VER($RETTYPE m_name$ARG) \\ virtual $RETVAL _##m_name($FUNCARGS) $CONST override; \\ """ sproto = str(argcount) if returns: sproto += "R" s = s.replace("$RETTYPE", "m_ret, ") s = s.replace("$RETVAL", "m_ret") else: s = s.replace("$RETTYPE", "") s = s.replace("$RETVAL", "void") if const: sproto += "C" s = s.replace("$CONST", "const") else: s = s.replace("$CONST", "") s = s.replace("$VER", sproto) argtext = "" funcargs = "" for i in range(argcount): if i > 0: funcargs += ", " argtext += ", m_type" + str(i + 1) funcargs += "m_type" + str(i + 1) + " arg" + str(i + 1) if argcount: s = s.replace("$ARG", argtext) s = s.replace("$FUNCARGS", funcargs) else: s = s.replace("$ARG", "") s = s.replace("$FUNCARGS", funcargs) return s def generate_wrappers(target): max_versions = 12 txt = """ #ifndef GDEXTENSION_WRAPPERS_GEN_H #define GDEXTENSION_WRAPPERS_GEN_H """ for i in range(max_versions + 1): txt += "\n/* Module Wrapper " + str(i) + " Arguments */\n" txt += generate_mod_version(i, False, False) txt += generate_mod_version(i, False, True) txt += generate_mod_version(i, True, False) txt += generate_mod_version(i, True, True) txt += "\n#endif\n" with open(target, "w", encoding="utf-8") as f: f.write(txt) def generate_virtual_version(argcount, const=False, returns=False): s = """#define GDVIRTUAL$VER($RET m_name $ARG)\\ ::godot::StringName _gdvirtual_##m_name##_sn = #m_name;\\ template \\ _FORCE_INLINE_ bool _gdvirtual_##m_name##_call($CALLARGS) $CONST {\\ if (::godot::internal::gdextension_interface_object_has_script_method(_owner, &_gdvirtual_##m_name##_sn)) { \\ GDExtensionCallError ce;\\ $CALLSIARGS\\ ::godot::Variant ret;\\ ::godot::internal::gdextension_interface_object_call_script_method(_owner, &_gdvirtual_##m_name##_sn, $CALLSIARGPASS, &ret, &ce);\\ if (ce.error == GDEXTENSION_CALL_OK) {\\ $CALLSIRET\\ return true;\\ }\\ }\\ if (required) {\\ ERR_PRINT_ONCE("Required virtual method " + get_class() + "::" + #m_name + " must be overridden before calling.");\\ $RVOID\\ }\\ return false;\\ }\\ _FORCE_INLINE_ bool _gdvirtual_##m_name##_overridden() const {\\ return ::godot::internal::gdextension_interface_object_has_script_method(_owner, &_gdvirtual_##m_name##_sn); \\ }\\ _FORCE_INLINE_ static ::godot::MethodInfo _gdvirtual_##m_name##_get_method_info() {\\ ::godot::MethodInfo method_info;\\ method_info.name = #m_name;\\ method_info.flags = $METHOD_FLAGS;\\ $FILL_METHOD_INFO\\ return method_info;\\ } """ sproto = str(argcount) method_info = "" if returns: sproto += "R" s = s.replace("$RET", "m_ret,") s = s.replace("$RVOID", "(void)r_ret;") # If required, may lead to uninitialized errors method_info += "method_info.return_val = ::godot::GetTypeInfo::get_class_info();\\\n" method_info += "\t\tmethod_info.return_val_metadata = ::godot::GetTypeInfo::METADATA;" else: s = s.replace("$RET ", "") s = s.replace("\t\t\t$RVOID\\\n", "") if const: sproto += "C" s = s.replace("$CONST", "const") s = s.replace("$METHOD_FLAGS", "::godot::METHOD_FLAG_VIRTUAL | ::godot::METHOD_FLAG_CONST") else: s = s.replace("$CONST ", "") s = s.replace("$METHOD_FLAGS", "::godot::METHOD_FLAG_VIRTUAL") s = s.replace("$VER", sproto) argtext = "" callargtext = "" callsiargs = "" callsiargptrs = "" if argcount > 0: argtext += ", " callsiargs = f"::godot::Variant vargs[{argcount}] = {{ " callsiargptrs = f"\t\t\tconst ::godot::Variant *vargptrs[{argcount}] = {{ " for i in range(argcount): if i > 0: argtext += ", " callargtext += ", " callsiargs += ", " callsiargptrs += ", " argtext += f"m_type{i + 1}" callargtext += f"m_type{i + 1} arg{i + 1}" callsiargs += f"::godot::Variant(arg{i + 1})" callsiargptrs += f"&vargs[{i}]" if method_info: method_info += "\\\n\t\t" method_info += f"method_info.arguments.push_back(::godot::GetTypeInfo::get_class_info());\\\n" method_info += f"\t\tmethod_info.arguments_metadata.push_back(::godot::GetTypeInfo::METADATA);" if argcount: callsiargs += " };\\\n" callsiargptrs += " };" s = s.replace("$CALLSIARGS", callsiargs + callsiargptrs) s = s.replace("$CALLSIARGPASS", f"(const GDExtensionConstVariantPtr *)vargptrs, {argcount}") else: s = s.replace("\t\t\t$CALLSIARGS\\\n", "") s = s.replace("$CALLSIARGPASS", "nullptr, 0") if returns: if argcount > 0: callargtext += ", " callargtext += "m_ret &r_ret" s = s.replace("$CALLSIRET", "r_ret = ::godot::VariantCaster::cast(ret);") else: s = s.replace("\t\t\t\t$CALLSIRET\\\n", "") s = s.replace(" $ARG", argtext) s = s.replace("$CALLARGS", callargtext) if method_info: s = s.replace("$FILL_METHOD_INFO", method_info) else: s = s.replace("\t\t$FILL_METHOD_INFO\\\n", method_info) return s def generate_virtuals(target): max_versions = 12 txt = """/* THIS FILE IS GENERATED DO NOT EDIT */ #ifndef GDEXTENSION_GDVIRTUAL_GEN_H #define GDEXTENSION_GDVIRTUAL_GEN_H """ for i in range(max_versions + 1): txt += f"/* {i} Arguments */\n\n" txt += generate_virtual_version(i, False, False) txt += generate_virtual_version(i, False, True) txt += generate_virtual_version(i, True, False) txt += generate_virtual_version(i, True, True) txt += "#endif // GDEXTENSION_GDVIRTUAL_GEN_H\n" with open(target, "w", encoding="utf-8") as f: f.write(txt) def get_file_list(api_filepath, output_dir, headers=False, sources=False, profile_filepath=""): api = {} files = [] with open(api_filepath, encoding="utf-8") as api_file: api = json.load(api_file) build_profile = parse_build_profile(profile_filepath, api) core_gen_folder = Path(output_dir) / "gen" / "include" / "godot_cpp" / "core" include_gen_folder = Path(output_dir) / "gen" / "include" / "godot_cpp" source_gen_folder = Path(output_dir) / "gen" / "src" files.append(str((core_gen_folder / "ext_wrappers.gen.inc").as_posix())) files.append(str((core_gen_folder / "gdvirtual.gen.inc").as_posix())) for builtin_class in api["builtin_classes"]: if is_pod_type(builtin_class["name"]): continue if is_included_type(builtin_class["name"]): continue header_filename = include_gen_folder / "variant" / (camel_to_snake(builtin_class["name"]) + ".hpp") source_filename = source_gen_folder / "variant" / (camel_to_snake(builtin_class["name"]) + ".cpp") if headers: files.append(str(header_filename.as_posix())) if sources: files.append(str(source_filename.as_posix())) for engine_class in api["classes"]: # Generate code for the ClassDB singleton under a different name. if engine_class["name"] == "ClassDB": engine_class["name"] = "ClassDBSingleton" engine_class["alias_for"] = "ClassDB" header_filename = include_gen_folder / "classes" / (camel_to_snake(engine_class["name"]) + ".hpp") source_filename = source_gen_folder / "classes" / (camel_to_snake(engine_class["name"]) + ".cpp") if headers: files.append(str(header_filename.as_posix())) if sources and is_class_included(engine_class["name"], build_profile): files.append(str(source_filename.as_posix())) for native_struct in api["native_structures"]: struct_name = native_struct["name"] if struct_name == "ObjectID": continue snake_struct_name = camel_to_snake(struct_name) header_filename = include_gen_folder / "classes" / (snake_struct_name + ".hpp") if headers: files.append(str(header_filename.as_posix())) if headers: for path in [ include_gen_folder / "variant" / "builtin_types.hpp", include_gen_folder / "variant" / "builtin_binds.hpp", include_gen_folder / "variant" / "utility_functions.hpp", include_gen_folder / "variant" / "variant_size.hpp", include_gen_folder / "variant" / "builtin_vararg_methods.hpp", include_gen_folder / "classes" / "global_constants.hpp", include_gen_folder / "classes" / "global_constants_binds.hpp", include_gen_folder / "core" / "version.hpp", ]: files.append(str(path.as_posix())) if sources: utility_functions_source_path = source_gen_folder / "variant" / "utility_functions.cpp" files.append(str(utility_functions_source_path.as_posix())) return files def print_file_list(api_filepath, output_dir, headers=False, sources=False, profile_filepath=""): print(*get_file_list(api_filepath, output_dir, headers, sources, profile_filepath), sep=";", end=None) def parse_build_profile(profile_filepath, api): if profile_filepath == "": return {} print("Using feature build profile: " + profile_filepath) with open(profile_filepath, encoding="utf-8") as profile_file: profile = json.load(profile_file) api_dict = {} parents = {} children = {} for engine_class in api["classes"]: api_dict[engine_class["name"]] = engine_class parent = engine_class.get("inherits", "") child = engine_class["name"] parents[child] = parent if parent == "": continue children[parent] = children.get(parent, []) children[parent].append(child) # Parse methods dependencies deps = {} reverse_deps = {} for name, engine_class in api_dict.items(): ref_cls = set() for method in engine_class.get("methods", []): rtype = method.get("return_value", {}).get("type", "") args = [a["type"] for a in method.get("arguments", [])] if rtype in api_dict: ref_cls.add(rtype) elif is_enum(rtype) and get_enum_class(rtype) in api_dict: ref_cls.add(get_enum_class(rtype)) for arg in args: if arg in api_dict: ref_cls.add(arg) elif is_enum(arg) and get_enum_class(arg) in api_dict: ref_cls.add(get_enum_class(arg)) deps[engine_class["name"]] = set(filter(lambda x: x != name, ref_cls)) for acls in ref_cls: if acls == name: continue reverse_deps[acls] = reverse_deps.get(acls, set()) reverse_deps[acls].add(name) included = [] front = list(profile.get("enabled_classes", [])) if front: # These must always be included front.append("WorkerThreadPool") front.append("ClassDB") front.append("ClassDBSingleton") while front: cls = front.pop() if cls in included: continue included.append(cls) parent = parents.get(cls, "") if parent: front.append(parent) for rcls in deps.get(cls, set()): if rcls in included or rcls in front: continue front.append(rcls) excluded = [] front = list(profile.get("disabled_classes", [])) while front: cls = front.pop() if cls in excluded: continue excluded.append(cls) front += children.get(cls, []) for rcls in reverse_deps.get(cls, set()): if rcls in excluded or rcls in front: continue front.append(rcls) if included and excluded: print( "WARNING: Cannot specify both 'enabled_classes' and 'disabled_classes' in build profile. 'disabled_classes' will be ignored." ) return { "enabled_classes": included, "disabled_classes": excluded, } def scons_emit_files(target, source, env): profile_filepath = env.get("build_profile", "") if profile_filepath and not Path(profile_filepath).is_absolute(): profile_filepath = str((Path(env.Dir("#").abspath) / profile_filepath).as_posix()) files = [env.File(f) for f in get_file_list(str(source[0]), target[0].abspath, True, True, profile_filepath)] env.Clean(target, files) env["godot_cpp_gen_dir"] = target[0].abspath return files, source def scons_generate_bindings(target, source, env): generate_bindings( str(source[0]), env["generate_template_get_node"], "32" if "32" in env["arch"] else "64", env["precision"], env["godot_cpp_gen_dir"], ) return None def generate_bindings(api_filepath, use_template_get_node, bits="64", precision="single", output_dir="."): api = None target_dir = Path(output_dir) / "gen" with open(api_filepath, encoding="utf-8") as api_file: api = json.load(api_file) shutil.rmtree(target_dir, ignore_errors=True) target_dir.mkdir(parents=True) real_t = "double" if precision == "double" else "float" print("Built-in type config: " + real_t + "_" + bits) generate_global_constants(api, target_dir) generate_version_header(api, target_dir) generate_global_constant_binds(api, target_dir) generate_builtin_bindings(api, target_dir, real_t + "_" + bits) generate_engine_classes_bindings(api, target_dir, use_template_get_node) generate_utility_functions(api, target_dir) CLASS_ALIASES = { "ClassDB": "ClassDBSingleton", } builtin_classes = [] # Key is class name, value is boolean where True means the class is refcounted. engine_classes = {} # Type names of native structures native_structures = [] singletons = [] def generate_builtin_bindings(api, output_dir, build_config): global builtin_classes core_gen_folder = Path(output_dir) / "include" / "godot_cpp" / "core" include_gen_folder = Path(output_dir) / "include" / "godot_cpp" / "variant" source_gen_folder = Path(output_dir) / "src" / "variant" core_gen_folder.mkdir(parents=True, exist_ok=True) include_gen_folder.mkdir(parents=True, exist_ok=True) source_gen_folder.mkdir(parents=True, exist_ok=True) generate_wrappers(core_gen_folder / "ext_wrappers.gen.inc") generate_virtuals(core_gen_folder / "gdvirtual.gen.inc") # Store types beforehand. for builtin_api in api["builtin_classes"]: if is_pod_type(builtin_api["name"]): continue builtin_classes.append(builtin_api["name"]) builtin_sizes = {} for size_list in api["builtin_class_sizes"]: if size_list["build_configuration"] == build_config: for size in size_list["sizes"]: builtin_sizes[size["name"]] = size["size"] break # Create a file for Variant size, since that class isn't generated. variant_size_filename = include_gen_folder / "variant_size.hpp" with variant_size_filename.open("+w", encoding="utf-8") as variant_size_file: variant_size_source = [] add_header("variant_size.hpp", variant_size_source) header_guard = "GODOT_CPP_VARIANT_SIZE_HPP" variant_size_source.append(f"#ifndef {header_guard}") variant_size_source.append(f"#define {header_guard}") variant_size_source.append(f'#define GODOT_CPP_VARIANT_SIZE {builtin_sizes["Variant"]}') variant_size_source.append(f"#endif // ! {header_guard}") variant_size_file.write("\n".join(variant_size_source)) for builtin_api in api["builtin_classes"]: if is_pod_type(builtin_api["name"]): continue if is_included_type(builtin_api["name"]): continue size = builtin_sizes[builtin_api["name"]] header_filename = include_gen_folder / (camel_to_snake(builtin_api["name"]) + ".hpp") source_filename = source_gen_folder / (camel_to_snake(builtin_api["name"]) + ".cpp") # Check used classes for header include used_classes = set() fully_used_classes = set() class_name = builtin_api["name"] if "constructors" in builtin_api: for constructor in builtin_api["constructors"]: if "arguments" in constructor: for argument in constructor["arguments"]: if is_included(argument["type"], class_name): if "default_value" in argument and argument["type"] != "Variant": fully_used_classes.add(argument["type"]) else: used_classes.add(argument["type"]) if "methods" in builtin_api: for method in builtin_api["methods"]: if "arguments" in method: for argument in method["arguments"]: if is_included(argument["type"], class_name): if "default_value" in argument and argument["type"] != "Variant": fully_used_classes.add(argument["type"]) else: used_classes.add(argument["type"]) if "return_type" in method: if is_included(method["return_type"], class_name): used_classes.add(method["return_type"]) if "members" in builtin_api: for member in builtin_api["members"]: if is_included(member["type"], class_name): used_classes.add(member["type"]) if "indexing_return_type" in builtin_api: if is_included(builtin_api["indexing_return_type"], class_name): used_classes.add(builtin_api["indexing_return_type"]) if "operators" in builtin_api: for operator in builtin_api["operators"]: if "right_type" in operator: if is_included(operator["right_type"], class_name): used_classes.add(operator["right_type"]) for type_name in fully_used_classes: if type_name in used_classes: used_classes.remove(type_name) used_classes = list(used_classes) used_classes.sort() fully_used_classes = list(fully_used_classes) fully_used_classes.sort() with header_filename.open("w+", encoding="utf-8") as header_file: header_file.write(generate_builtin_class_header(builtin_api, size, used_classes, fully_used_classes)) with source_filename.open("w+", encoding="utf-8") as source_file: source_file.write(generate_builtin_class_source(builtin_api, size, used_classes, fully_used_classes)) # Create a header with all builtin types for convenience. builtin_header_filename = include_gen_folder / "builtin_types.hpp" with builtin_header_filename.open("w+", encoding="utf-8") as builtin_header_file: builtin_header = [] add_header("builtin_types.hpp", builtin_header) builtin_header.append("#ifndef GODOT_CPP_BUILTIN_TYPES_HPP") builtin_header.append("#define GODOT_CPP_BUILTIN_TYPES_HPP") builtin_header.append("") for builtin in builtin_classes: builtin_header.append(f"#include ") builtin_header.append("") builtin_header.append("#endif // ! GODOT_CPP_BUILTIN_TYPES_HPP") builtin_header_file.write("\n".join(builtin_header)) # Create a header with bindings for builtin types. builtin_binds_filename = include_gen_folder / "builtin_binds.hpp" with builtin_binds_filename.open("w+", encoding="utf-8") as builtin_binds_file: builtin_binds = [] add_header("builtin_binds.hpp", builtin_binds) builtin_binds.append("#ifndef GODOT_CPP_BUILTIN_BINDS_HPP") builtin_binds.append("#define GODOT_CPP_BUILTIN_BINDS_HPP") builtin_binds.append("") builtin_binds.append("#include ") builtin_binds.append("") for builtin_api in api["builtin_classes"]: if is_included_type(builtin_api["name"]): if "enums" in builtin_api: for enum_api in builtin_api["enums"]: builtin_binds.append(f"VARIANT_ENUM_CAST({builtin_api['name']}::{enum_api['name']});") builtin_binds.append("") builtin_binds.append("#endif // ! GODOT_CPP_BUILTIN_BINDS_HPP") builtin_binds_file.write("\n".join(builtin_binds)) # Create a header to implement all builtin class vararg methods and be included in "variant.hpp". builtin_vararg_methods_header = include_gen_folder / "builtin_vararg_methods.hpp" builtin_vararg_methods_header.open("w+").write( generate_builtin_class_vararg_method_implements_header(api["builtin_classes"]) ) def generate_builtin_class_vararg_method_implements_header(builtin_classes): result = [] add_header("builtin_vararg_methods.hpp", result) header_guard = "GODOT_CPP_BUILTIN_VARARG_METHODS_HPP" result.append(f"#ifndef {header_guard}") result.append(f"#define {header_guard}") result.append("") for builtin_api in builtin_classes: if "methods" not in builtin_api: continue class_name = builtin_api["name"] for method in builtin_api["methods"]: if not method["is_vararg"]: continue result += make_varargs_template( method, "is_static" in method and method["is_static"], class_name, False, False, True ) result.append("") result.append("") result.append(f"#endif // ! {header_guard}") return "\n".join(result) def generate_builtin_class_header(builtin_api, size, used_classes, fully_used_classes): result = [] class_name = builtin_api["name"] snake_class_name = camel_to_snake(class_name).upper() header_guard = f"GODOT_CPP_{snake_class_name}_HPP" add_header(f"{snake_class_name.lower()}.hpp", result) result.append(f"#ifndef {header_guard}") result.append(f"#define {header_guard}") result.append("") result.append("#include ") result.append("") # Special cases. if class_name == "String": result.append("#include ") result.append("#include ") result.append("#include ") if class_name == "PackedStringArray": result.append("#include ") if class_name == "PackedColorArray": result.append("#include ") if class_name == "PackedVector2Array": result.append("#include ") if class_name == "PackedVector3Array": result.append("#include ") if class_name == "PackedVector4Array": result.append("#include ") if is_packed_array(class_name): result.append("#include ") result.append("#include ") if class_name == "Array": result.append("#include ") if class_name == "Callable": result.append("#include ") for include in fully_used_classes: if include == "TypedArray": result.append("#include ") else: result.append(f"#include ") if len(fully_used_classes) > 0: result.append("") result.append("#include ") result.append("") result.append("namespace godot {") result.append("") for type_name in used_classes: if is_struct_type(type_name): result.append(f"struct {type_name};") else: result.append(f"class {type_name};") if len(used_classes) > 0: result.append("") result.append(f"class {class_name} {{") result.append(f"\tstatic constexpr size_t {snake_class_name}_SIZE = {size};") result.append(f"\tuint8_t opaque[{snake_class_name}_SIZE] = {{}};") result.append("") result.append("\tfriend class Variant;") if class_name == "String": result.append("\tfriend class StringName;") result.append("") result.append("\tstatic struct _MethodBindings {") result.append("\t\tGDExtensionTypeFromVariantConstructorFunc from_variant_constructor;") if "constructors" in builtin_api: for constructor in builtin_api["constructors"]: result.append(f'\t\tGDExtensionPtrConstructor constructor_{constructor["index"]};') if builtin_api["has_destructor"]: result.append("\t\tGDExtensionPtrDestructor destructor;") if "methods" in builtin_api: for method in builtin_api["methods"]: result.append(f'\t\tGDExtensionPtrBuiltInMethod method_{method["name"]};') if "members" in builtin_api: for member in builtin_api["members"]: result.append(f'\t\tGDExtensionPtrSetter member_{member["name"]}_setter;') result.append(f'\t\tGDExtensionPtrGetter member_{member["name"]}_getter;') if "indexing_return_type" in builtin_api: result.append("\t\tGDExtensionPtrIndexedSetter indexed_setter;") result.append("\t\tGDExtensionPtrIndexedGetter indexed_getter;") if "is_keyed" in builtin_api and builtin_api["is_keyed"]: result.append("\t\tGDExtensionPtrKeyedSetter keyed_setter;") result.append("\t\tGDExtensionPtrKeyedGetter keyed_getter;") result.append("\t\tGDExtensionPtrKeyedChecker keyed_checker;") if "operators" in builtin_api: for operator in builtin_api["operators"]: if "right_type" in operator: result.append( f'\t\tGDExtensionPtrOperatorEvaluator operator_{get_operator_id_name(operator["name"])}_{operator["right_type"]};' ) else: result.append(f'\t\tGDExtensionPtrOperatorEvaluator operator_{get_operator_id_name(operator["name"])};') result.append("\t} _method_bindings;") result.append("") result.append("\tstatic void init_bindings();") result.append("\tstatic void _init_bindings_constructors_destructor();") result.append("") result.append(f"\t{class_name}(const Variant *p_variant);") result.append("") result.append("public:") result.append( f"\t_FORCE_INLINE_ GDExtensionTypePtr _native_ptr() const {{ return const_cast(&opaque); }}" ) copy_constructor_index = -1 if "constructors" in builtin_api: for constructor in builtin_api["constructors"]: method_signature = f"\t{class_name}(" if "arguments" in constructor: method_signature += make_function_parameters( constructor["arguments"], include_default=True, for_builtin=True ) if len(constructor["arguments"]) == 1 and constructor["arguments"][0]["type"] == class_name: copy_constructor_index = constructor["index"] method_signature += ");" result.append(method_signature) # Move constructor. result.append(f"\t{class_name}({class_name} &&p_other);") # Special cases. if class_name == "String" or class_name == "StringName" or class_name == "NodePath": if class_name == "StringName": result.append(f"\t{class_name}(const char *p_from, bool p_static = false);") else: result.append(f"\t{class_name}(const char *p_from);") result.append(f"\t{class_name}(const wchar_t *p_from);") result.append(f"\t{class_name}(const char16_t *p_from);") result.append(f"\t{class_name}(const char32_t *p_from);") if class_name == "Callable": result.append("\tCallable(CallableCustom *p_custom);") result.append("\tCallableCustom *get_custom() const;") if "constants" in builtin_api: axis_constants_count = 0 for constant in builtin_api["constants"]: # Special case: Vector3.Axis is the only enum in the bindings. # It's technically not supported by Variant but works for direct access. if class_name == "Vector3" and constant["name"].startswith("AXIS"): if axis_constants_count == 0: result.append("\tenum Axis {") result.append(f'\t\t{constant["name"]} = {constant["value"]},') axis_constants_count += 1 if axis_constants_count == 3: result.append("\t};") else: result.append(f'\tstatic const {correct_type(constant["type"])} {constant["name"]};') if builtin_api["has_destructor"]: result.append(f"\t~{class_name}();") method_list = [] if "methods" in builtin_api: for method in builtin_api["methods"]: method_list.append(method["name"]) vararg = method["is_vararg"] if vararg: result.append("\ttemplate ") method_signature = "\t" if "is_static" in method and method["is_static"]: method_signature += "static " if "return_type" in method: method_signature += f'{correct_type(method["return_type"])}' if not method_signature.endswith("*"): method_signature += " " else: method_signature += "void " method_signature += f'{method["name"]}(' method_arguments = [] if "arguments" in method: method_arguments = method["arguments"] method_signature += make_function_parameters( method_arguments, include_default=True, for_builtin=True, is_vararg=vararg ) method_signature += ")" if method["is_const"]: method_signature += " const" method_signature += ";" result.append(method_signature) # Special cases. if class_name == "String": result.append("\tstatic String utf8(const char *p_from, int64_t p_len = -1);") result.append("\tError parse_utf8(const char *p_from, int64_t p_len = -1);") result.append("\tstatic String utf16(const char16_t *p_from, int64_t p_len = -1);") result.append( "\tError parse_utf16(const char16_t *p_from, int64_t p_len = -1, bool p_default_little_endian = true);" ) result.append("\tCharString utf8() const;") result.append("\tCharString ascii() const;") result.append("\tChar16String utf16() const;") result.append("\tChar32String utf32() const;") result.append("\tCharWideString wide_string() const;") result.append("\tstatic String num_real(double p_num, bool p_trailing = true);") result.append("\tError resize(int64_t p_size);") if "members" in builtin_api: for member in builtin_api["members"]: if f'get_{member["name"]}' not in method_list: result.append(f'\t{correct_type(member["type"])} get_{member["name"]}() const;') if f'set_{member["name"]}' not in method_list: result.append(f'\tvoid set_{member["name"]}({type_for_parameter(member["type"])}value);') if "operators" in builtin_api: for operator in builtin_api["operators"]: if is_valid_cpp_operator(operator["name"]): if "right_type" in operator: result.append( f'\t{correct_type(operator["return_type"])} operator{get_operator_cpp_name(operator["name"])}({type_for_parameter(operator["right_type"])}p_other) const;' ) else: result.append( f'\t{correct_type(operator["return_type"])} operator{get_operator_cpp_name(operator["name"])}() const;' ) # Copy assignment. if copy_constructor_index >= 0: result.append(f"\t{class_name} &operator=(const {class_name} &p_other);") # Move assignment. result.append(f"\t{class_name} &operator=({class_name} &&p_other);") # Special cases. if class_name == "String": result.append("\tString &operator=(const char *p_str);") result.append("\tString &operator=(const wchar_t *p_str);") result.append("\tString &operator=(const char16_t *p_str);") result.append("\tString &operator=(const char32_t *p_str);") result.append("\tbool operator==(const char *p_str) const;") result.append("\tbool operator==(const wchar_t *p_str) const;") result.append("\tbool operator==(const char16_t *p_str) const;") result.append("\tbool operator==(const char32_t *p_str) const;") result.append("\tbool operator!=(const char *p_str) const;") result.append("\tbool operator!=(const wchar_t *p_str) const;") result.append("\tbool operator!=(const char16_t *p_str) const;") result.append("\tbool operator!=(const char32_t *p_str) const;") result.append("\tString operator+(const char *p_str);") result.append("\tString operator+(const wchar_t *p_str);") result.append("\tString operator+(const char16_t *p_str);") result.append("\tString operator+(const char32_t *p_str);") result.append("\tString operator+(char32_t p_char);") result.append("\tString &operator+=(const String &p_str);") result.append("\tString &operator+=(char32_t p_char);") result.append("\tString &operator+=(const char *p_str);") result.append("\tString &operator+=(const wchar_t *p_str);") result.append("\tString &operator+=(const char32_t *p_str);") result.append("\tconst char32_t &operator[](int64_t p_index) const;") result.append("\tchar32_t &operator[](int64_t p_index);") result.append("\tconst char32_t *ptr() const;") result.append("\tchar32_t *ptrw();") if class_name == "Array": result.append("\ttemplate ") result.append("\tstatic Array make(Args... p_args) {") result.append("\t\treturn helpers::append_all(Array(), p_args...);") result.append("\t}") if is_packed_array(class_name): return_type = correct_type(builtin_api["indexing_return_type"]) if class_name == "PackedByteArray": return_type = "uint8_t" elif class_name == "PackedInt32Array": return_type = "int32_t" elif class_name == "PackedFloat32Array": return_type = "float" result.append(f"\tconst {return_type} &operator[](int64_t p_index) const;") result.append(f"\t{return_type} &operator[](int64_t p_index);") result.append(f"\tconst {return_type} *ptr() const;") result.append(f"\t{return_type} *ptrw();") iterators = """ struct Iterator { _FORCE_INLINE_ $TYPE &operator*() const { return *elem_ptr; } _FORCE_INLINE_ $TYPE *operator->() const { return elem_ptr; } _FORCE_INLINE_ Iterator &operator++() { elem_ptr++; return *this; } _FORCE_INLINE_ Iterator &operator--() { elem_ptr--; return *this; } _FORCE_INLINE_ bool operator==(const Iterator &b) const { return elem_ptr == b.elem_ptr; } _FORCE_INLINE_ bool operator!=(const Iterator &b) const { return elem_ptr != b.elem_ptr; } Iterator($TYPE *p_ptr) { elem_ptr = p_ptr; } Iterator() {} Iterator(const Iterator &p_it) { elem_ptr = p_it.elem_ptr; } private: $TYPE *elem_ptr = nullptr; }; struct ConstIterator { _FORCE_INLINE_ const $TYPE &operator*() const { return *elem_ptr; } _FORCE_INLINE_ const $TYPE *operator->() const { return elem_ptr; } _FORCE_INLINE_ ConstIterator &operator++() { elem_ptr++; return *this; } _FORCE_INLINE_ ConstIterator &operator--() { elem_ptr--; return *this; } _FORCE_INLINE_ bool operator==(const ConstIterator &b) const { return elem_ptr == b.elem_ptr; } _FORCE_INLINE_ bool operator!=(const ConstIterator &b) const { return elem_ptr != b.elem_ptr; } ConstIterator(const $TYPE *p_ptr) { elem_ptr = p_ptr; } ConstIterator() {} ConstIterator(const ConstIterator &p_it) { elem_ptr = p_it.elem_ptr; } private: const $TYPE *elem_ptr = nullptr; }; _FORCE_INLINE_ Iterator begin() { return Iterator(ptrw()); } _FORCE_INLINE_ Iterator end() { return Iterator(ptrw() + size()); } _FORCE_INLINE_ ConstIterator begin() const { return ConstIterator(ptr()); } _FORCE_INLINE_ ConstIterator end() const { return ConstIterator(ptr() + size()); } """ result.append(iterators.replace("$TYPE", return_type)) init_list = """ _FORCE_INLINE_ $CLASS(std::initializer_list<$TYPE> p_init) { ERR_FAIL_COND(resize(p_init.size()) != 0); size_t i = 0; for (const $TYPE &element : p_init) { set(i++, element); } } """ result.append(init_list.replace("$TYPE", return_type).replace("$CLASS", class_name)) if class_name == "Array": result.append("\tconst Variant &operator[](int64_t p_index) const;") result.append("\tVariant &operator[](int64_t p_index);") result.append("\tvoid set_typed(uint32_t p_type, const StringName &p_class_name, const Variant &p_script);") result.append("\tvoid _ref(const Array &p_from) const;") if class_name == "Dictionary": result.append("\tconst Variant &operator[](const Variant &p_key) const;") result.append("\tVariant &operator[](const Variant &p_key);") result.append("};") if class_name == "String": result.append("") result.append("bool operator==(const char *p_chr, const String &p_str);") result.append("bool operator==(const wchar_t *p_chr, const String &p_str);") result.append("bool operator==(const char16_t *p_chr, const String &p_str);") result.append("bool operator==(const char32_t *p_chr, const String &p_str);") result.append("bool operator!=(const char *p_chr, const String &p_str);") result.append("bool operator!=(const wchar_t *p_chr, const String &p_str);") result.append("bool operator!=(const char16_t *p_chr, const String &p_str);") result.append("bool operator!=(const char32_t *p_chr, const String &p_str);") result.append("String operator+(const char *p_chr, const String &p_str);") result.append("String operator+(const wchar_t *p_chr, const String &p_str);") result.append("String operator+(const char16_t *p_chr, const String &p_str);") result.append("String operator+(const char32_t *p_chr, const String &p_str);") result.append("String operator+(char32_t p_char, const String &p_str);") result.append("String itos(int64_t p_val);") result.append("String uitos(uint64_t p_val);") result.append("String rtos(double p_val);") result.append("String rtoss(double p_val);") result.append("") result.append("} // namespace godot") result.append(f"#endif // ! {header_guard}") return "\n".join(result) def generate_builtin_class_source(builtin_api, size, used_classes, fully_used_classes): result = [] class_name = builtin_api["name"] snake_class_name = camel_to_snake(class_name) enum_type_name = f"GDEXTENSION_VARIANT_TYPE_{snake_class_name.upper()}" add_header(f"{snake_class_name}.cpp", result) result.append("") result.append(f"#include ") result.append("") result.append("#include ") result.append("") result.append("#include ") result.append("") # Only used since the "fully used" is included in header already. for include in used_classes: result.append(f"#include ") if len(used_classes) > 0: result.append("") result.append("#include ") result.append("") result.append("#include ") result.append("") result.append("namespace godot {") result.append("") result.append(f"{class_name}::_MethodBindings {class_name}::_method_bindings;") result.append("") result.append(f"void {class_name}::_init_bindings_constructors_destructor() {{") result.append( f"\t_method_bindings.from_variant_constructor = internal::gdextension_interface_get_variant_to_type_constructor({enum_type_name});" ) if "constructors" in builtin_api: for constructor in builtin_api["constructors"]: result.append( f'\t_method_bindings.constructor_{constructor["index"]} = internal::gdextension_interface_variant_get_ptr_constructor({enum_type_name}, {constructor["index"]});' ) if builtin_api["has_destructor"]: result.append( f"\t_method_bindings.destructor = internal::gdextension_interface_variant_get_ptr_destructor({enum_type_name});" ) result.append("}") result.append(f"void {class_name}::init_bindings() {{") # StringName's constructor internally uses String, so it constructor must be ready ! if class_name == "StringName": result.append("\tString::_init_bindings_constructors_destructor();") result.append(f"\t{class_name}::_init_bindings_constructors_destructor();") result.append("\tStringName _gde_name;") if "methods" in builtin_api: for method in builtin_api["methods"]: # TODO: Add error check for hash mismatch. result.append(f'\t_gde_name = StringName("{method["name"]}");') result.append( f'\t_method_bindings.method_{method["name"]} = internal::gdextension_interface_variant_get_ptr_builtin_method({enum_type_name}, _gde_name._native_ptr(), {method["hash"]});' ) if "members" in builtin_api: for member in builtin_api["members"]: result.append(f'\t_gde_name = StringName("{member["name"]}");') result.append( f'\t_method_bindings.member_{member["name"]}_setter = internal::gdextension_interface_variant_get_ptr_setter({enum_type_name}, _gde_name._native_ptr());' ) result.append( f'\t_method_bindings.member_{member["name"]}_getter = internal::gdextension_interface_variant_get_ptr_getter({enum_type_name}, _gde_name._native_ptr());' ) if "indexing_return_type" in builtin_api: result.append( f"\t_method_bindings.indexed_setter = internal::gdextension_interface_variant_get_ptr_indexed_setter({enum_type_name});" ) result.append( f"\t_method_bindings.indexed_getter = internal::gdextension_interface_variant_get_ptr_indexed_getter({enum_type_name});" ) if "is_keyed" in builtin_api and builtin_api["is_keyed"]: result.append( f"\t_method_bindings.keyed_setter = internal::gdextension_interface_variant_get_ptr_keyed_setter({enum_type_name});" ) result.append( f"\t_method_bindings.keyed_getter = internal::gdextension_interface_variant_get_ptr_keyed_getter({enum_type_name});" ) result.append( f"\t_method_bindings.keyed_checker = internal::gdextension_interface_variant_get_ptr_keyed_checker({enum_type_name});" ) if "operators" in builtin_api: for operator in builtin_api["operators"]: if "right_type" in operator: if operator["right_type"] == "Variant": right_type_variant_type = "GDEXTENSION_VARIANT_TYPE_NIL" else: right_type_variant_type = ( f"GDEXTENSION_VARIANT_TYPE_{camel_to_snake(operator['right_type']).upper()}" ) result.append( f'\t_method_bindings.operator_{get_operator_id_name(operator["name"])}_{operator["right_type"]} = internal::gdextension_interface_variant_get_ptr_operator_evaluator(GDEXTENSION_VARIANT_OP_{get_operator_id_name(operator["name"]).upper()}, {enum_type_name}, {right_type_variant_type});' ) else: result.append( f'\t_method_bindings.operator_{get_operator_id_name(operator["name"])} = internal::gdextension_interface_variant_get_ptr_operator_evaluator(GDEXTENSION_VARIANT_OP_{get_operator_id_name(operator["name"]).upper()}, {enum_type_name}, GDEXTENSION_VARIANT_TYPE_NIL);' ) result.append("}") result.append("") copy_constructor_index = -1 result.append(f"{class_name}::{class_name}(const Variant *p_variant) {{") result.append("\t_method_bindings.from_variant_constructor(&opaque, p_variant->_native_ptr());") result.append("}") result.append("") if "constructors" in builtin_api: for constructor in builtin_api["constructors"]: method_signature = f"{class_name}::{class_name}(" if "arguments" in constructor: method_signature += make_function_parameters( constructor["arguments"], include_default=False, for_builtin=True ) method_signature += ") {" result.append(method_signature) method_call = ( f'\tinternal::_call_builtin_constructor(_method_bindings.constructor_{constructor["index"]}, &opaque' ) if "arguments" in constructor: if len(constructor["arguments"]) == 1 and constructor["arguments"][0]["type"] == class_name: copy_constructor_index = constructor["index"] method_call += ", " arguments = [] for argument in constructor["arguments"]: (encode, arg_name) = get_encoded_arg( argument["name"], argument["type"], argument["meta"] if "meta" in argument else None, ) result += encode arguments.append(arg_name) method_call += ", ".join(arguments) method_call += ");" result.append(method_call) result.append("}") result.append("") # Move constructor. result.append(f"{class_name}::{class_name}({class_name} &&p_other) {{") if needs_copy_instead_of_move(class_name) and copy_constructor_index >= 0: result.append( f"\tinternal::_call_builtin_constructor(_method_bindings.constructor_{copy_constructor_index}, &opaque, &p_other);" ) else: result.append("\tstd::swap(opaque, p_other.opaque);") result.append("}") result.append("") if builtin_api["has_destructor"]: result.append(f"{class_name}::~{class_name}() {{") result.append("\t_method_bindings.destructor(&opaque);") result.append("}") result.append("") method_list = [] if "methods" in builtin_api: for method in builtin_api["methods"]: method_list.append(method["name"]) if "is_vararg" in method and method["is_vararg"]: # Done in the header because of the template. continue method_signature = make_signature(class_name, method, for_builtin=True) result.append(method_signature + " {") method_call = "\t" is_ref = False if "return_type" in method: return_type = method["return_type"] if is_enum(return_type): method_call += f"return ({get_gdextension_type(correct_type(return_type))})internal::_call_builtin_method_ptr_ret(" elif is_pod_type(return_type) or is_variant(return_type): method_call += f"return internal::_call_builtin_method_ptr_ret<{get_gdextension_type(correct_type(return_type))}>(" elif is_refcounted(return_type): method_call += f"return Ref<{return_type}>::_gde_internal_constructor(internal::_call_builtin_method_ptr_ret_obj<{return_type}>(" is_ref = True else: method_call += f"return internal::_call_builtin_method_ptr_ret_obj<{return_type}>(" else: method_call += "internal::_call_builtin_method_ptr_no_ret(" method_call += f'_method_bindings.method_{method["name"]}, ' if "is_static" in method and method["is_static"]: method_call += "nullptr" else: method_call += "(GDExtensionTypePtr)&opaque" if "arguments" in method: arguments = [] method_call += ", " for argument in method["arguments"]: (encode, arg_name) = get_encoded_arg( argument["name"], argument["type"], argument["meta"] if "meta" in argument else None, ) result += encode arguments.append(arg_name) method_call += ", ".join(arguments) if is_ref: method_call += ")" # Close Ref<> constructor. method_call += ");" result.append(method_call) result.append("}") result.append("") if "members" in builtin_api: for member in builtin_api["members"]: if f'get_{member["name"]}' not in method_list: result.append(f'{correct_type(member["type"])} {class_name}::get_{member["name"]}() const {{') result.append( f'\treturn internal::_call_builtin_ptr_getter<{correct_type(member["type"])}>(_method_bindings.member_{member["name"]}_getter, (GDExtensionConstTypePtr)&opaque);' ) result.append("}") if f'set_{member["name"]}' not in method_list: result.append(f'void {class_name}::set_{member["name"]}({type_for_parameter(member["type"])}value) {{') (encode, arg_name) = get_encoded_arg("value", member["type"], None) result += encode result.append( f'\t_method_bindings.member_{member["name"]}_setter((GDExtensionConstTypePtr)&opaque, (GDExtensionConstTypePtr){arg_name});' ) result.append("}") result.append("") if "operators" in builtin_api: for operator in builtin_api["operators"]: if is_valid_cpp_operator(operator["name"]): if "right_type" in operator: result.append( f'{correct_type(operator["return_type"])} {class_name}::operator{get_operator_cpp_name(operator["name"])}({type_for_parameter(operator["right_type"])}p_other) const {{' ) (encode, arg_name) = get_encoded_arg("other", operator["right_type"], None) result += encode result.append( f'\treturn internal::_call_builtin_operator_ptr<{get_gdextension_type(correct_type(operator["return_type"]))}>(_method_bindings.operator_{get_operator_id_name(operator["name"])}_{operator["right_type"]}, (GDExtensionConstTypePtr)&opaque, (GDExtensionConstTypePtr){arg_name});' ) result.append("}") else: result.append( f'{correct_type(operator["return_type"])} {class_name}::operator{get_operator_cpp_name(operator["name"])}() const {{' ) result.append( f'\treturn internal::_call_builtin_operator_ptr<{get_gdextension_type(correct_type(operator["return_type"]))}>(_method_bindings.operator_{get_operator_id_name(operator["name"])}, (GDExtensionConstTypePtr)&opaque, (GDExtensionConstTypePtr)nullptr);' ) result.append("}") result.append("") # Copy assignment. if copy_constructor_index >= 0: result.append(f"{class_name} &{class_name}::operator=(const {class_name} &p_other) {{") if builtin_api["has_destructor"]: result.append("\t_method_bindings.destructor(&opaque);") (encode, arg_name) = get_encoded_arg( "other", class_name, None, ) result += encode result.append( f"\tinternal::_call_builtin_constructor(_method_bindings.constructor_{copy_constructor_index}, &opaque, {arg_name});" ) result.append("\treturn *this;") result.append("}") result.append("") # Move assignment. result.append(f"{class_name} &{class_name}::operator=({class_name} &&p_other) {{") if needs_copy_instead_of_move(class_name) and copy_constructor_index >= 0: result.append( f"\tinternal::_call_builtin_constructor(_method_bindings.constructor_{copy_constructor_index}, &opaque, &p_other);" ) else: result.append("\tstd::swap(opaque, p_other.opaque);") result.append("\treturn *this;") result.append("}") result.append("") result.append("} //namespace godot") return "\n".join(result) def generate_engine_classes_bindings(api, output_dir, use_template_get_node): global engine_classes global singletons global native_structures include_gen_folder = Path(output_dir) / "include" / "godot_cpp" / "classes" source_gen_folder = Path(output_dir) / "src" / "classes" include_gen_folder.mkdir(parents=True, exist_ok=True) source_gen_folder.mkdir(parents=True, exist_ok=True) # First create map of classes and singletons. for class_api in api["classes"]: # Generate code for the ClassDB singleton under a different name. if class_api["name"] in CLASS_ALIASES: class_api["alias_for"] = class_api["name"] class_api["name"] = CLASS_ALIASES[class_api["alias_for"]] engine_classes[class_api["name"]] = class_api["is_refcounted"] for native_struct in api["native_structures"]: if native_struct["name"] == "ObjectID": continue engine_classes[native_struct["name"]] = False native_structures.append(native_struct["name"]) for singleton in api["singletons"]: # Generate code for the ClassDB singleton under a different name. if singleton["name"] in CLASS_ALIASES: singleton["alias_for"] = singleton["name"] singleton["name"] = CLASS_ALIASES[singleton["name"]] singletons.append(singleton["name"]) for class_api in api["classes"]: # Check used classes for header include. used_classes = set() fully_used_classes = set() class_name = class_api["name"] header_filename = include_gen_folder / (camel_to_snake(class_api["name"]) + ".hpp") source_filename = source_gen_folder / (camel_to_snake(class_api["name"]) + ".cpp") if "methods" in class_api: for method in class_api["methods"]: if "arguments" in method: for argument in method["arguments"]: type_name = argument["type"] if type_name.startswith("const "): type_name = type_name[6:] if type_name.endswith("*"): type_name = type_name[:-1] if is_included(type_name, class_name): if type_name.startswith("typedarray::"): fully_used_classes.add("TypedArray") array_type_name = type_name.replace("typedarray::", "") if array_type_name.startswith("const "): array_type_name = array_type_name[6:] if array_type_name.endswith("*"): array_type_name = array_type_name[:-1] if is_included(array_type_name, class_name): if is_enum(array_type_name): fully_used_classes.add(get_enum_class(array_type_name)) elif "default_value" in argument: fully_used_classes.add(array_type_name) else: used_classes.add(array_type_name) elif is_enum(type_name): fully_used_classes.add(get_enum_class(type_name)) elif "default_value" in argument: fully_used_classes.add(type_name) else: used_classes.add(type_name) if is_refcounted(type_name): fully_used_classes.add("Ref") if "return_value" in method: type_name = method["return_value"]["type"] if type_name.startswith("const "): type_name = type_name[6:] if type_name.endswith("*"): type_name = type_name[:-1] if is_included(type_name, class_name): if type_name.startswith("typedarray::"): fully_used_classes.add("TypedArray") array_type_name = type_name.replace("typedarray::", "") if array_type_name.startswith("const "): array_type_name = array_type_name[6:] if array_type_name.endswith("*"): array_type_name = array_type_name[:-1] if is_included(array_type_name, class_name): if is_enum(array_type_name): fully_used_classes.add(get_enum_class(array_type_name)) elif is_variant(array_type_name): fully_used_classes.add(array_type_name) else: used_classes.add(array_type_name) elif is_enum(type_name): fully_used_classes.add(get_enum_class(type_name)) elif is_variant(type_name): fully_used_classes.add(type_name) else: used_classes.add(type_name) if is_refcounted(type_name): fully_used_classes.add("Ref") if "members" in class_api: for member in class_api["members"]: if is_included(member["type"], class_name): if is_enum(member["type"]): fully_used_classes.add(get_enum_class(member["type"])) else: used_classes.add(member["type"]) if is_refcounted(member["type"]): fully_used_classes.add("Ref") if "inherits" in class_api: if is_included(class_api["inherits"], class_name): fully_used_classes.add(class_api["inherits"]) if is_refcounted(class_api["name"]): fully_used_classes.add("Ref") else: fully_used_classes.add("Wrapped") # In order to ensure that PtrToArg specializations for native structs are # always used, let's move any of them into 'fully_used_classes'. for type_name in used_classes: if is_struct_type(type_name) and not is_included_struct_type(type_name): fully_used_classes.add(type_name) for type_name in fully_used_classes: if type_name in used_classes: used_classes.remove(type_name) used_classes = list(used_classes) used_classes.sort() fully_used_classes = list(fully_used_classes) fully_used_classes.sort() with header_filename.open("w+", encoding="utf-8") as header_file: header_file.write( generate_engine_class_header(class_api, used_classes, fully_used_classes, use_template_get_node) ) with source_filename.open("w+", encoding="utf-8") as source_file: source_file.write( generate_engine_class_source(class_api, used_classes, fully_used_classes, use_template_get_node) ) for native_struct in api["native_structures"]: struct_name = native_struct["name"] if struct_name == "ObjectID": continue snake_struct_name = camel_to_snake(struct_name) header_filename = include_gen_folder / (snake_struct_name + ".hpp") result = [] add_header(f"{snake_struct_name}.hpp", result) header_guard = f"GODOT_CPP_{snake_struct_name.upper()}_HPP" result.append(f"#ifndef {header_guard}") result.append(f"#define {header_guard}") used_classes = [] expanded_format = native_struct["format"].replace("(", " ").replace(")", ";").replace(",", ";") for field in expanded_format.split(";"): field_type = field.strip().split(" ")[0].split("::")[0] if field_type != "" and not is_included_type(field_type) and not is_pod_type(field_type): if field_type not in used_classes: used_classes.append(field_type) result.append("") for included in used_classes: result.append(f"#include ") if len(used_classes) == 0: result.append("#include ") result.append("") result.append("namespace godot {") result.append("") result.append(f"struct {struct_name} {{") for field in native_struct["format"].split(";"): if field != "": result.append(f"\t{field};") result.append("};") result.append("") result.append(f"GDVIRTUAL_NATIVE_PTR({struct_name});") result.append("") result.append("} // namespace godot") result.append("") result.append(f"#endif // ! {header_guard}") with header_filename.open("w+", encoding="utf-8") as header_file: header_file.write("\n".join(result)) def generate_engine_class_header(class_api, used_classes, fully_used_classes, use_template_get_node): global singletons result = [] class_name = class_api["name"] snake_class_name = camel_to_snake(class_name).upper() is_singleton = class_name in singletons add_header(f"{snake_class_name.lower()}.hpp", result) header_guard = f"GODOT_CPP_{snake_class_name}_HPP" result.append(f"#ifndef {header_guard}") result.append(f"#define {header_guard}") result.append("") for included in fully_used_classes: if included == "TypedArray": result.append("#include ") else: result.append(f"#include ") if class_name == "EditorPlugin": result.append("#include ") if len(fully_used_classes) > 0: result.append("") if class_name != "Object" and class_name != "ClassDBSingleton": result.append("#include ") result.append("") result.append("#include ") result.append("") if class_name == "ClassDBSingleton": result.append("#include ") result.append("") result.append("namespace godot {") result.append("") for type_name in used_classes: if is_struct_type(type_name): result.append(f"struct {type_name};") else: result.append(f"class {type_name};") if len(used_classes) > 0: result.append("") inherits = class_api["inherits"] if "inherits" in class_api else "Wrapped" result.append(f"class {class_name} : public {inherits} {{") if "alias_for" in class_api: result.append(f"\tGDEXTENSION_CLASS_ALIAS({class_name}, {class_api['alias_for']}, {inherits})") else: result.append(f"\tGDEXTENSION_CLASS({class_name}, {inherits})") result.append("") if is_singleton: result.append(f"\tstatic {class_name} *singleton;") result.append("") result.append("public:") result.append("") if "enums" in class_api: for enum_api in class_api["enums"]: if enum_api["is_bitfield"]: result.append(f'\tenum {enum_api["name"]} : uint64_t {{') else: result.append(f'\tenum {enum_api["name"]} {{') for value in enum_api["values"]: result.append(f'\t\t{value["name"]} = {value["value"]},') result.append("\t};") result.append("") if "constants" in class_api: for value in class_api["constants"]: if "type" not in value: value["type"] = "int" result.append(f'\tstatic const {value["type"]} {value["name"]} = {value["value"]};') result.append("") if is_singleton: result.append(f"\tstatic {class_name} *get_singleton();") result.append("") if "methods" in class_api: for method in class_api["methods"]: if method["is_virtual"]: # Will be done later. continue vararg = "is_vararg" in method and method["is_vararg"] method_signature = "\t" method_signature += make_signature( class_name, method, for_header=True, use_template_get_node=use_template_get_node ) result.append(method_signature + ";") if vararg: # Add templated version. result += make_varargs_template(method) # Virtuals now. for method in class_api["methods"]: if not method["is_virtual"]: continue method_signature = "\t" method_signature += make_signature( class_name, method, for_header=True, use_template_get_node=use_template_get_node ) result.append(method_signature + ";") result.append("protected:") # T is the custom class we want to register (from which the call initiates, going up the inheritance chain), # B is its base class (can be a custom class too, that's why we pass it). result.append("\ttemplate ") result.append("\tstatic void register_virtuals() {") if class_name != "Object": result.append(f"\t\t{inherits}::register_virtuals();") if "methods" in class_api: for method in class_api["methods"]: if not method["is_virtual"]: continue method_name = escape_identifier(method["name"]) result.append( # If the method is different from the base class, it means T overrides it, so it needs to be bound. # Note that with an `if constexpr`, the code inside the `if` will not even be compiled if the # condition returns false (in such cases it can't compile due to ambiguity). f"\t\tif constexpr (!std::is_same_v) {{" ) result.append(f"\t\t\tBIND_VIRTUAL_METHOD(T, {method_name});") result.append("\t\t}") result.append("\t}") result.append("") if is_singleton: result.append(f"\t~{class_name}();") result.append("") result.append("public:") # Special cases. if class_name == "XMLParser": result.append("\tError _open_buffer(const uint8_t *p_buffer, size_t p_size);") if class_name == "Image": result.append("\tuint8_t *ptrw();") result.append("\tconst uint8_t *ptr();") if class_name == "FileAccess": result.append("\tuint64_t get_buffer(uint8_t *p_dst, uint64_t p_length) const;") result.append("\tvoid store_buffer(const uint8_t *p_src, uint64_t p_length);") if class_name == "WorkerThreadPool": result.append("\tenum {") result.append("\tINVALID_TASK_ID = -1") result.append("\t};") result.append("\ttypedef int64_t TaskID;") result.append("\ttypedef int64_t GroupID;") result.append( "\tTaskID add_native_task(void (*p_func)(void *), void *p_userdata, bool p_high_priority = false, const String &p_description = String());" ) result.append( "\tGroupID add_native_group_task(void (*p_func)(void *, uint32_t), void *p_userdata, int p_elements, int p_tasks = -1, bool p_high_priority = false, const String &p_description = String());" ) if class_name == "Object": result.append("") result.append("\ttemplate ") result.append("\tstatic T *cast_to(Object *p_object);") result.append("\ttemplate ") result.append("\tstatic const T *cast_to(const Object *p_object);") result.append("\tvirtual ~Object() = default;") elif use_template_get_node and class_name == "Node": result.append("\ttemplate ") result.append( "\tT *get_node(const NodePath &p_path) const { return Object::cast_to(get_node_internal(p_path)); }" ) result.append("") result.append("};") result.append("") result.append("} // namespace godot") result.append("") if "enums" in class_api and class_name != "Object": for enum_api in class_api["enums"]: if enum_api["is_bitfield"]: result.append(f'VARIANT_BITFIELD_CAST({class_name}::{enum_api["name"]});') else: result.append(f'VARIANT_ENUM_CAST({class_name}::{enum_api["name"]});') result.append("") if class_name == "ClassDBSingleton": result.append("#define CLASSDB_SINGLETON_FORWARD_METHODS \\") if "enums" in class_api: for enum_api in class_api["enums"]: if enum_api["is_bitfield"]: result.append(f'\tenum {enum_api["name"]} : uint64_t {{ \\') else: result.append(f'\tenum {enum_api["name"]} {{ \\') for value in enum_api["values"]: result.append(f'\t\t{value["name"]} = {value["value"]}, \\') result.append("\t}; \\") result.append("\t \\") for method in class_api["methods"]: # ClassDBSingleton shouldn't have any static methods, but if some appear later, lets skip them. if "is_static" in method and method["is_static"]: continue vararg = "is_vararg" in method and method["is_vararg"] if vararg: method_signature = "\ttemplate static " else: method_signature = "\tstatic " return_type = None if "return_type" in method: return_type = correct_type(method["return_type"].replace("ClassDBSingleton", "ClassDB"), None, False) elif "return_value" in method: return_type = correct_type( method["return_value"]["type"].replace("ClassDBSingleton", "ClassDB"), method["return_value"].get("meta", None), False, ) if return_type is not None: method_signature += return_type if not method_signature.endswith("*"): method_signature += " " else: method_signature += "void " method_signature += f'{method["name"]}(' method_arguments = [] if "arguments" in method: method_arguments = method["arguments"] method_signature += make_function_parameters( method_arguments, include_default=True, for_builtin=True, is_vararg=vararg ) method_signature += ") { \\" result.append(method_signature) method_body = "\t\t" if return_type is not None: method_body += "return " if "alias_for" in class_api and return_type.startswith(class_api["alias_for"] + "::"): method_body += f"({return_type})" method_body += f'ClassDBSingleton::get_singleton()->{method["name"]}(' method_body += ", ".join(map(lambda x: escape_argument(x["name"]), method_arguments)) if vararg: method_body += ", p_args..." method_body += "); \\" result.append(method_body) result.append("\t} \\") result.append("\t;") result.append("") result.append("#define CLASSDB_SINGLETON_VARIANT_CAST \\") if "enums" in class_api: for enum_api in class_api["enums"]: if enum_api["is_bitfield"]: result.append(f'\tVARIANT_BITFIELD_CAST({class_api["alias_for"]}::{enum_api["name"]}); \\') else: result.append(f'\tVARIANT_ENUM_CAST({class_api["alias_for"]}::{enum_api["name"]}); \\') result.append("\t;") result.append("") result.append(f"#endif // ! {header_guard}") return "\n".join(result) def generate_engine_class_source(class_api, used_classes, fully_used_classes, use_template_get_node): global singletons result = [] class_name = class_api["name"] snake_class_name = camel_to_snake(class_name) is_singleton = class_name in singletons add_header(f"{snake_class_name}.cpp", result) result.append(f"#include ") result.append("") result.append("#include ") result.append("#include ") result.append("#include ") result.append("") for included in used_classes: result.append(f"#include ") if len(used_classes) > 0: result.append("") result.append("namespace godot {") result.append("") if is_singleton: result.append(f"{class_name} *{class_name}::singleton = nullptr;") result.append("") result.append(f"{class_name} *{class_name}::get_singleton() {{") # We assume multi-threaded access is OK because each assignment will assign the same value every time result.append("\tif (unlikely(singleton == nullptr)) {") result.append( f"\t\tGDExtensionObjectPtr singleton_obj = internal::gdextension_interface_global_get_singleton({class_name}::get_class_static()._native_ptr());" ) result.append("#ifdef DEBUG_ENABLED") result.append("\t\tERR_FAIL_NULL_V(singleton_obj, nullptr);") result.append("#endif // DEBUG_ENABLED") result.append( f"\t\tsingleton = reinterpret_cast<{class_name} *>(internal::gdextension_interface_object_get_instance_binding(singleton_obj, internal::token, &{class_name}::_gde_binding_callbacks));" ) result.append("#ifdef DEBUG_ENABLED") result.append("\t\tERR_FAIL_NULL_V(singleton, nullptr);") result.append("#endif // DEBUG_ENABLED") result.append("\t\tif (likely(singleton)) {") result.append(f"\t\t\tClassDB::_register_engine_singleton({class_name}::get_class_static(), singleton);") result.append("\t\t}") result.append("\t}") result.append("\treturn singleton;") result.append("}") result.append("") result.append(f"{class_name}::~{class_name}() {{") result.append("\tif (singleton == this) {") result.append(f"\t\tClassDB::_unregister_engine_singleton({class_name}::get_class_static());") result.append("\t\tsingleton = nullptr;") result.append("\t}") result.append("}") result.append("") if "methods" in class_api: for method in class_api["methods"]: if method["is_virtual"]: # Will be done later continue vararg = "is_vararg" in method and method["is_vararg"] # Method signature. method_signature = make_signature(class_name, method, use_template_get_node=use_template_get_node) result.append(method_signature + " {") # Method body. result.append( f'\tstatic GDExtensionMethodBindPtr _gde_method_bind = internal::gdextension_interface_classdb_get_method_bind({class_name}::get_class_static()._native_ptr(), StringName("{method["name"]}")._native_ptr(), {method["hash"]});' ) method_call = "\t" has_return = "return_value" in method and method["return_value"]["type"] != "void" if has_return: result.append( f'\tCHECK_METHOD_BIND_RET(_gde_method_bind, {get_default_value_for_type(method["return_value"]["type"])});' ) else: result.append("\tCHECK_METHOD_BIND(_gde_method_bind);") is_ref = False if not vararg: if has_return: return_type = method["return_value"]["type"] meta_type = method["return_value"]["meta"] if "meta" in method["return_value"] else None if is_enum(return_type): if method["is_static"]: method_call += f"return ({get_gdextension_type(correct_type(return_type, meta_type))})internal::_call_native_mb_ret(_gde_method_bind, nullptr" else: method_call += f"return ({get_gdextension_type(correct_type(return_type, meta_type))})internal::_call_native_mb_ret(_gde_method_bind, _owner" elif is_pod_type(return_type) or is_variant(return_type): if method["is_static"]: method_call += f"return internal::_call_native_mb_ret<{get_gdextension_type(correct_type(return_type, meta_type))}>(_gde_method_bind, nullptr" else: method_call += f"return internal::_call_native_mb_ret<{get_gdextension_type(correct_type(return_type, meta_type))}>(_gde_method_bind, _owner" elif is_refcounted(return_type): if method["is_static"]: method_call += f"return Ref<{return_type}>::_gde_internal_constructor(internal::_call_native_mb_ret_obj<{return_type}>(_gde_method_bind, nullptr" else: method_call += f"return Ref<{return_type}>::_gde_internal_constructor(internal::_call_native_mb_ret_obj<{return_type}>(_gde_method_bind, _owner" is_ref = True else: if method["is_static"]: method_call += ( f"return internal::_call_native_mb_ret_obj<{return_type}>(_gde_method_bind, nullptr" ) else: method_call += ( f"return internal::_call_native_mb_ret_obj<{return_type}>(_gde_method_bind, _owner" ) else: if method["is_static"]: method_call += "internal::_call_native_mb_no_ret(_gde_method_bind, nullptr" else: method_call += "internal::_call_native_mb_no_ret(_gde_method_bind, _owner" if "arguments" in method: method_call += ", " arguments = [] for argument in method["arguments"]: (encode, arg_name) = get_encoded_arg( argument["name"], argument["type"], argument["meta"] if "meta" in argument else None, ) result += encode arguments.append(arg_name) method_call += ", ".join(arguments) else: # vararg. result.append("\tGDExtensionCallError error;") result.append("\tVariant ret;") method_call += "internal::gdextension_interface_object_method_bind_call(_gde_method_bind, _owner, reinterpret_cast(p_args), p_arg_count, &ret, &error" if is_ref: method_call += ")" # Close Ref<> constructor. method_call += ");" result.append(method_call) if vararg and ("return_value" in method and method["return_value"]["type"] != "void"): return_type = get_enum_fullname(method["return_value"]["type"]) if return_type != "Variant": result.append(f"\treturn VariantCaster<{return_type}>::cast(ret);") else: result.append("\treturn ret;") result.append("}") result.append("") # Virtuals now. for method in class_api["methods"]: if not method["is_virtual"]: continue method_signature = make_signature(class_name, method, use_template_get_node=use_template_get_node) method_signature += " {" if "return_value" in method and correct_type(method["return_value"]["type"]) != "void": result.append(method_signature) result.append(f'\treturn {get_default_value_for_type(method["return_value"]["type"])};') result.append("}") else: method_signature += "}" result.append(method_signature) result.append("") result.append("") result.append("} // namespace godot ") return "\n".join(result) def generate_global_constants(api, output_dir): include_gen_folder = Path(output_dir) / "include" / "godot_cpp" / "classes" source_gen_folder = Path(output_dir) / "src" / "classes" include_gen_folder.mkdir(parents=True, exist_ok=True) source_gen_folder.mkdir(parents=True, exist_ok=True) # Generate header header = [] add_header("global_constants.hpp", header) header_filename = include_gen_folder / "global_constants.hpp" header_guard = "GODOT_CPP_GLOBAL_CONSTANTS_HPP" header.append(f"#ifndef {header_guard}") header.append(f"#define {header_guard}") header.append("") header.append("#include ") header.append("") header.append("namespace godot {") header.append("") for constant in api["global_constants"]: header.append(f'\tconst int64_t {escape_identifier(constant["name"])} = {constant["value"]};') header.append("") for enum_def in api["global_enums"]: if enum_def["name"].startswith("Variant."): continue if enum_def["is_bitfield"]: header.append(f'\tenum {enum_def["name"]} : uint64_t {{') else: header.append(f'\tenum {enum_def["name"]} {{') for value in enum_def["values"]: header.append(f'\t\t{value["name"]} = {value["value"]},') header.append("\t};") header.append("") header.append("} // namespace godot") header.append("") header.append(f"#endif // ! {header_guard}") with header_filename.open("w+", encoding="utf-8") as header_file: header_file.write("\n".join(header)) def generate_version_header(api, output_dir): header = [] header_filename = "version.hpp" add_header(header_filename, header) include_gen_folder = Path(output_dir) / "include" / "godot_cpp" / "core" include_gen_folder.mkdir(parents=True, exist_ok=True) header_file_path = include_gen_folder / header_filename header_guard = "GODOT_CPP_VERSION_HPP" header.append(f"#ifndef {header_guard}") header.append(f"#define {header_guard}") header.append("") header.append(f"#define GODOT_VERSION_MAJOR {api['header']['version_major']}") header.append(f"#define GODOT_VERSION_MINOR {api['header']['version_minor']}") header.append(f"#define GODOT_VERSION_PATCH {api['header']['version_patch']}") header.append(f"#define GODOT_VERSION_STATUS \"{api['header']['version_status']}\"") header.append(f"#define GODOT_VERSION_BUILD \"{api['header']['version_build']}\"") header.append("") header.append(f"#endif // {header_guard}") header.append("") with header_file_path.open("w+", encoding="utf-8") as header_file: header_file.write("\n".join(header)) def generate_global_constant_binds(api, output_dir): include_gen_folder = Path(output_dir) / "include" / "godot_cpp" / "classes" source_gen_folder = Path(output_dir) / "src" / "classes" include_gen_folder.mkdir(parents=True, exist_ok=True) source_gen_folder.mkdir(parents=True, exist_ok=True) # Generate header header = [] add_header("global_constants_binds.hpp", header) header_filename = include_gen_folder / "global_constants_binds.hpp" header_guard = "GODOT_CPP_GLOBAL_CONSTANTS_BINDS_HPP" header.append(f"#ifndef {header_guard}") header.append(f"#define {header_guard}") header.append("") header.append("#include ") header.append("") for enum_def in api["global_enums"]: if enum_def["name"].startswith("Variant."): continue if enum_def["is_bitfield"]: header.append(f'VARIANT_BITFIELD_CAST({enum_def["name"]});') else: header.append(f'VARIANT_ENUM_CAST({enum_def["name"]});') # Variant::Type is not a global enum, but only one line, it is worth to place in this file instead of creating new file. header.append("VARIANT_ENUM_CAST(godot::Variant::Type);") header.append("") header.append(f"#endif // ! {header_guard}") with header_filename.open("w+", encoding="utf-8") as header_file: header_file.write("\n".join(header)) def generate_utility_functions(api, output_dir): include_gen_folder = Path(output_dir) / "include" / "godot_cpp" / "variant" source_gen_folder = Path(output_dir) / "src" / "variant" include_gen_folder.mkdir(parents=True, exist_ok=True) source_gen_folder.mkdir(parents=True, exist_ok=True) # Generate header. header = [] add_header("utility_functions.hpp", header) header_filename = include_gen_folder / "utility_functions.hpp" header_guard = "GODOT_CPP_UTILITY_FUNCTIONS_HPP" header.append(f"#ifndef {header_guard}") header.append(f"#define {header_guard}") header.append("") header.append("#include ") header.append("#include ") header.append("") header.append("#include ") header.append("") header.append("namespace godot {") header.append("") header.append("class UtilityFunctions {") header.append("public:") for function in api["utility_functions"]: vararg = "is_vararg" in function and function["is_vararg"] function_signature = "\t" function_signature += make_signature("UtilityFunctions", function, for_header=True, static=True) header.append(function_signature + ";") if vararg: # Add templated version. header += make_varargs_template(function, static=True) header.append("};") header.append("") header.append("} // namespace godot") header.append("") header.append(f"#endif // ! {header_guard}") with header_filename.open("w+", encoding="utf-8") as header_file: header_file.write("\n".join(header)) # Generate source. source = [] add_header("utility_functions.cpp", source) source_filename = source_gen_folder / "utility_functions.cpp" source.append("#include ") source.append("") source.append("#include ") source.append("#include ") source.append("") source.append("namespace godot {") source.append("") for function in api["utility_functions"]: vararg = "is_vararg" in function and function["is_vararg"] function_signature = make_signature("UtilityFunctions", function) source.append(function_signature + " {") # Function body. source.append( f'\tstatic GDExtensionPtrUtilityFunction _gde_function = internal::gdextension_interface_variant_get_ptr_utility_function(StringName("{function["name"]}")._native_ptr(), {function["hash"]});' ) has_return = "return_type" in function and function["return_type"] != "void" if has_return: source.append( f'\tCHECK_METHOD_BIND_RET(_gde_function, {get_default_value_for_type(function["return_type"])});' ) else: source.append("\tCHECK_METHOD_BIND(_gde_function);") function_call = "\t" if not vararg: if has_return: function_call += "return " if function["return_type"] == "Object": function_call += "internal::_call_utility_ret_obj(_gde_function" else: function_call += f'internal::_call_utility_ret<{get_gdextension_type(correct_type(function["return_type"]))}>(_gde_function' else: function_call += "internal::_call_utility_no_ret(_gde_function" if "arguments" in function: function_call += ", " arguments = [] for argument in function["arguments"]: (encode, arg_name) = get_encoded_arg( argument["name"], argument["type"], argument["meta"] if "meta" in argument else None, ) source += encode arguments.append(arg_name) function_call += ", ".join(arguments) else: if has_return: source.append(f'\t{get_gdextension_type(correct_type(function["return_type"]))} ret;') else: source.append("\tVariant ret;") function_call += "_gde_function(&ret, reinterpret_cast(p_args), p_arg_count" function_call += ");" source.append(function_call) if vararg and has_return: source.append("\treturn ret;") source.append("}") source.append("") source.append("} // namespace godot") with source_filename.open("w+", encoding="utf-8") as source_file: source_file.write("\n".join(source)) # Helper functions. def camel_to_snake(name): name = re.sub("(.)([A-Z][a-z]+)", r"\1_\2", name) name = re.sub("([a-z0-9])([A-Z])", r"\1_\2", name) return name.replace("2_D", "2D").replace("3_D", "3D").lower() def make_function_parameters(parameters, include_default=False, for_builtin=False, is_vararg=False): signature = [] for index, par in enumerate(parameters): parameter = type_for_parameter(par["type"], par["meta"] if "meta" in par else None) parameter_name = escape_argument(par["name"]) if len(parameter_name) == 0: parameter_name = "p_arg_" + str(index + 1) parameter += parameter_name if include_default and "default_value" in par and (not for_builtin or par["type"] != "Variant"): parameter += " = " if is_enum(par["type"]): parameter_type = correct_type(par["type"]) if parameter_type == "void": parameter_type = "Variant" parameter += f"({parameter_type})" parameter += correct_default_value(par["default_value"], par["type"]) signature.append(parameter) if is_vararg: signature.append("const Args&... p_args") return ", ".join(signature) def type_for_parameter(type_name, meta=None): if type_name == "void": return "Variant " elif is_pod_type(type_name) and type_name != "Nil" or is_enum(type_name): return f"{correct_type(type_name, meta)} " elif is_variant(type_name) or is_refcounted(type_name): return f"const {correct_type(type_name)} &" else: return f"{correct_type(type_name)}" def get_include_path(type_name): base_dir = "" if type_name == "Object": base_dir = "core" elif is_variant(type_name): base_dir = "variant" else: base_dir = "classes" return f"{base_dir}/{camel_to_snake(type_name)}.hpp" def get_encoded_arg(arg_name, type_name, type_meta): result = [] name = escape_argument(arg_name) arg_type = correct_type(type_name) if is_pod_type(arg_type): result.append(f"\t{get_gdextension_type(arg_type)} {name}_encoded;") result.append(f"\tPtrToArg<{correct_type(type_name)}>::encode({name}, &{name}_encoded);") name = f"&{name}_encoded" elif is_engine_class(type_name): # `{name}` is a C++ wrapper, it contains a field which is the object's pointer Godot expects. # We have to check `nullptr` because when the caller sends `nullptr`, the wrapper itself will be null. name = f"({name} != nullptr ? &{name}->_owner : nullptr)" else: name = f"&{name}" return (result, name) def make_signature( class_name, function_data, for_header=False, use_template_get_node=True, for_builtin=False, static=False ): function_signature = "" is_vararg = "is_vararg" in function_data and function_data["is_vararg"] if for_header: if "is_virtual" in function_data and function_data["is_virtual"]: function_signature += "virtual " if is_vararg: function_signature += "private: " if static: function_signature += "static " return_type = "void" return_meta = None if "return_type" in function_data: return_type = correct_type(function_data["return_type"]) elif "return_value" in function_data: return_type = function_data["return_value"]["type"] return_meta = function_data["return_value"]["meta"] if "meta" in function_data["return_value"] else None function_signature += correct_type( return_type, return_meta, ) if not function_signature.endswith("*"): function_signature += " " if not for_header: function_signature += f"{class_name}::" function_signature += escape_identifier(function_data["name"]) if is_vararg or ( not for_builtin and use_template_get_node and class_name == "Node" and function_data["name"] == "get_node" ): function_signature += "_internal" function_signature += "(" arguments = function_data["arguments"] if "arguments" in function_data else [] if not is_vararg: function_signature += make_function_parameters(arguments, for_header, for_builtin, is_vararg) else: function_signature += "const Variant **p_args, GDExtensionInt p_arg_count" function_signature += ")" if "is_static" in function_data and function_data["is_static"] and for_header: function_signature = "static " + function_signature elif "is_const" in function_data and function_data["is_const"]: function_signature += " const" return function_signature def make_varargs_template( function_data, static=False, class_befor_signature="", with_public_declare=True, with_indent=True, for_builtin_classes=False, ): result = [] function_signature = "" if with_public_declare: function_signature = "public: " function_signature += "template " if static: function_signature += "static " return_type = "void" return_meta = None if "return_type" in function_data: return_type = correct_type(function_data["return_type"]) elif "return_value" in function_data: return_type = function_data["return_value"]["type"] return_meta = function_data["return_value"]["meta"] if "meta" in function_data["return_value"] else None function_signature += correct_type( return_type, return_meta, ) if not function_signature.endswith("*"): function_signature += " " if len(class_befor_signature) > 0: function_signature += class_befor_signature + "::" function_signature += f'{escape_identifier(function_data["name"])}' method_arguments = [] if "arguments" in function_data: method_arguments = function_data["arguments"] function_signature += "(" is_vararg = "is_vararg" in function_data and function_data["is_vararg"] function_signature += make_function_parameters(method_arguments, include_default=True, is_vararg=is_vararg) function_signature += ")" if "is_const" in function_data and function_data["is_const"]: function_signature += " const" function_signature += " {" result.append(function_signature) args_array = f"\tstd::array variant_args {{ " for argument in method_arguments: if argument["type"] == "Variant": args_array += escape_argument(argument["name"]) else: args_array += f'Variant({escape_argument(argument["name"])})' args_array += ", " args_array += "Variant(p_args)... };" result.append(args_array) result.append(f"\tstd::array call_args;") result.append("\tfor (size_t i = 0; i < variant_args.size(); i++) {") result.append("\t\tcall_args[i] = &variant_args[i];") result.append("\t}") call_line = "\t" if not for_builtin_classes: if return_type != "void": call_line += "return " call_line += f'{escape_identifier(function_data["name"])}_internal(call_args.data(), variant_args.size());' result.append(call_line) else: base = "(GDExtensionTypePtr)&opaque" if static: base = "nullptr" ret = "nullptr" if return_type != "void": ret = "&ret" result.append(f'\t{correct_type(function_data["return_type"])} ret;') function_name = function_data["name"] result.append( f"\t_method_bindings.method_{function_name}({base}, reinterpret_cast(call_args.data()), {ret}, {len(method_arguments)} + sizeof...(Args));" ) if return_type != "void": result.append("\treturn ret;") result.append("}") if with_indent: for i in range(len(result)): result[i] = "\t" + result[i] return result # Engine idiosyncrasies. def is_pod_type(type_name): """ Those are types for which no class should be generated. """ return type_name in [ "Nil", "void", "bool", "real_t", "float", "double", "int", "int8_t", "uint8_t", "int16_t", "uint16_t", "int32_t", "int64_t", "uint32_t", "uint64_t", ] def is_included_type(type_name): # Types which we already have implemented. return is_included_struct_type(type_name) or type_name in ["ObjectID"] def is_included_struct_type(type_name): # Struct types which we already have implemented. return type_name in [ "AABB", "Basis", "Color", "Plane", "Projection", "Quaternion", "Rect2", "Rect2i", "Transform2D", "Transform3D", "Vector2", "Vector2i", "Vector3", "Vector3i", "Vector4", "Vector4i", ] def is_packed_array(type_name): """ Those are types for which we add our extra packed array functions. """ return type_name in [ "PackedByteArray", "PackedColorArray", "PackedFloat32Array", "PackedFloat64Array", "PackedInt32Array", "PackedInt64Array", "PackedStringArray", "PackedVector2Array", "PackedVector3Array", "PackedVector4Array", ] def needs_copy_instead_of_move(type_name): """ Those are types which need initialized data or we'll get warning spam so need a copy instead of move. """ return type_name in [ "Dictionary", ] def is_enum(type_name): return type_name.startswith("enum::") or type_name.startswith("bitfield::") def is_bitfield(type_name): return type_name.startswith("bitfield::") def get_enum_class(enum_name: str): if "." in enum_name: if is_bitfield(enum_name): return enum_name.replace("bitfield::", "").split(".")[0] else: return enum_name.replace("enum::", "").split(".")[0] else: return "GlobalConstants" def get_enum_fullname(enum_name: str): if is_bitfield(enum_name): return enum_name.replace("bitfield::", "BitField<") + ">" else: return enum_name.replace("enum::", "") def get_enum_name(enum_name: str): if is_bitfield(enum_name): return enum_name.replace("bitfield::", "").split(".")[-1] else: return enum_name.replace("enum::", "").split(".")[-1] def is_variant(type_name): return ( type_name == "Variant" or type_name in builtin_classes or type_name == "Nil" or type_name.startswith("typedarray::") ) def is_engine_class(type_name): global engine_classes return type_name == "Object" or type_name in engine_classes def is_struct_type(type_name): # This is used to determine which keyword to use for forward declarations. global native_structures return is_included_struct_type(type_name) or type_name in native_structures def is_refcounted(type_name): return type_name in engine_classes and engine_classes[type_name] def is_class_included(class_name, build_profile): """ Check if an engine class should be included. This removes classes according to a build profile of enabled or disabled classes. """ included = build_profile.get("enabled_classes", []) excluded = build_profile.get("disabled_classes", []) if included: return class_name in included if excluded: return class_name not in excluded return True def is_included(type_name, current_type): """ Check if a builtin type should be included. This removes Variant and POD types from inclusion, and the current type. """ if type_name.startswith("typedarray::"): return True to_include = get_enum_class(type_name) if is_enum(type_name) else type_name if to_include == current_type or is_pod_type(to_include): return False if to_include == "GlobalConstants" or to_include == "UtilityFunctions": return True return is_engine_class(to_include) or is_variant(to_include) def correct_default_value(value, type_name): value_map = { "null": "nullptr", '""': "String()", '&""': "StringName()", '^""': "NodePath()", "[]": "Array()", "{}": "Dictionary()", "Transform2D(1, 0, 0, 1, 0, 0)": "Transform2D()", # Default transform. "Transform3D(1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0)": "Transform3D()", # Default transform. } if value in value_map: return value_map[value] if value == "": return f"{type_name}()" if value.startswith("Array["): return "{}" if value.startswith("&"): return value[1::] if value.startswith("^"): return value[1::] return value def correct_typed_array(type_name): if type_name.startswith("typedarray::"): return type_name.replace("typedarray::", "TypedArray<") + ">" return type_name def correct_type(type_name, meta=None, use_alias=True): type_conversion = {"float": "double", "int": "int64_t", "Nil": "Variant"} if meta is not None: if "int" in meta: return f"{meta}_t" elif "char" in meta: return f"{meta}_t" else: return meta if type_name in type_conversion: return type_conversion[type_name] if type_name.startswith("typedarray::"): return type_name.replace("typedarray::", "TypedArray<") + ">" if is_enum(type_name): if is_bitfield(type_name): base_class = get_enum_class(type_name) if use_alias and base_class in CLASS_ALIASES: base_class = CLASS_ALIASES[base_class] if base_class == "GlobalConstants": return f"BitField<{get_enum_name(type_name)}>" return f"BitField<{base_class}::{get_enum_name(type_name)}>" else: base_class = get_enum_class(type_name) if use_alias and base_class in CLASS_ALIASES: base_class = CLASS_ALIASES[base_class] if base_class == "GlobalConstants": return f"{get_enum_name(type_name)}" return f"{base_class}::{get_enum_name(type_name)}" if is_refcounted(type_name): return f"Ref<{type_name}>" if type_name == "Object" or is_engine_class(type_name): return f"{type_name} *" if type_name.endswith("*") and not type_name.endswith("**") and not type_name.endswith(" *"): return f"{type_name[:-1]} *" return type_name def get_gdextension_type(type_name): type_conversion_map = { "bool": "int8_t", "uint8_t": "int64_t", "int8_t": "int64_t", "uint16_t": "int64_t", "int16_t": "int64_t", "uint32_t": "int64_t", "int32_t": "int64_t", "int": "int64_t", "float": "double", } if type_name.startswith("BitField<"): return "int64_t" if type_name in type_conversion_map: return type_conversion_map[type_name] return type_name def escape_identifier(id): cpp_keywords_map = { "class": "_class", "char": "_char", "short": "_short", "bool": "_bool", "int": "_int", "default": "_default", "case": "_case", "switch": "_switch", "export": "_export", "template": "_template", "new": "new_", "operator": "_operator", "typeof": "type_of", "typename": "type_name", "enum": "_enum", } if id in cpp_keywords_map: return cpp_keywords_map[id] return id def escape_argument(id): if id.startswith("p_") or id.startswith("r_"): return id return "p_" + id def get_operator_id_name(op): op_id_map = { "==": "equal", "!=": "not_equal", "<": "less", "<=": "less_equal", ">": "greater", ">=": "greater_equal", "+": "add", "-": "subtract", "*": "multiply", "/": "divide", "unary-": "negate", "unary+": "positive", "%": "module", "**": "power", "<<": "shift_left", ">>": "shift_right", "&": "bit_and", "|": "bit_or", "^": "bit_xor", "~": "bit_negate", "and": "and", "or": "or", "xor": "xor", "not": "not", "in": "in", } return op_id_map[op] def get_operator_cpp_name(op): op_cpp_map = { "==": "==", "!=": "!=", "<": "<", "<=": "<=", ">": ">", ">=": ">=", "+": "+", "-": "-", "*": "*", "/": "/", "unary-": "-", "unary+": "+", "%": "%", "<<": "<<", ">>": ">>", "&": "&", "|": "|", "^": "^", "~": "~", "and": "&&", "or": "||", "not": "!", } return op_cpp_map[op] def is_valid_cpp_operator(op): return op not in ["**", "xor", "in"] def get_default_value_for_type(type_name): if type_name == "int": return "0" if type_name == "float": return "0.0" if type_name == "bool": return "false" if type_name.startswith("typedarray::"): return f"{correct_type(type_name)}()" if is_enum(type_name): return f"{correct_type(type_name)}(0)" if is_variant(type_name): return f"{type_name}()" if is_refcounted(type_name): return f"Ref<{type_name}>()" return "nullptr" header = """\ /**************************************************************************/ /* $filename */ /**************************************************************************/ /* 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. */ /**************************************************************************/ """ def add_header(filename, lines): desired_length = len(header.split("\n")[0]) pad_spaces = desired_length - 6 - len(filename) for num, line in enumerate(header.split("\n")): if num == 1: new_line = f"/* {filename}{' ' * pad_spaces}*/" lines.append(new_line) else: lines.append(line) lines.append("// THIS FILE IS GENERATED. EDITS WILL BE LOST.") lines.append("")