Implement vararg methods of builtin classes.

Author: Daylily-Zeleen

binding_generator.py

@@ -121,6 +121,7 @@ def get_file_list(api_filepath, output_dir, headers=False, sources=False):
             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",
         ]:
@@ -342,6 +343,101 @@ def generate_builtin_bindings(api, output_dir, build_config):
 
         builtin_binds_file.write("\n".join(builtin_binds))
 
+    # Craete a header to implement all builin 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}")
+    for builtin_api in builtin_classes:
+        if not "methods" in builtin_api:
+            continue
+        class_name = builtin_api["name"]
+        for method in builtin_api["methods"]:
+            if not method["is_vararg"]:
+                continue
+
+            need_return = "return_type" in method
+
+            result.append("template<class... Args>")
+            method_signature = ""
+            if need_return:
+                method_signature += f'{correct_type(method["return_type"])} '
+            else:
+                method_signature += "void "
+
+            method_name = method["name"]
+            method_signature += f"{class_name}::{method_name}("
+
+            method_arguments = []
+            if "arguments" in method:
+                method_arguments = method["arguments"]
+
+            method_signature += make_function_parameters(
+                method_arguments, include_default=False, for_builtin=True, is_vararg=True
+            )
+
+            method_signature += ")"
+            if method["is_const"]:
+                method_signature += " const"
+
+            method_signature += "{"
+            result.append(method_signature)
+
+            arguments = []
+            if "arguments" in method:
+                for argument in method["arguments"]:
+                    arguments.append(escape_identifier(argument["name"]))
+
+            need_return = "return_type" in method
+
+            variant_args = f"\tstd::array<Variant, {len(arguments)} + sizeof...(Args)> variant_args = " + "{ { "
+            if len(arguments) > 0:
+                for i in range(len(arguments)):
+                    if i > 0:
+                        variant_args += ", "
+                    variant_args += f"Variant({arguments[i]})"
+                variant_args += ", "
+            variant_args += "(Variant(args))... } };"
+            result.append(variant_args)
+            result.append(f"\tstd::array<const Variant *, {len(arguments)} + sizeof...(Args)> call_args;")
+            result.append(f"\tfor (size_t i = 0; i < ({len(arguments)} + sizeof...(Args)); ++i) " + "{")
+            result.append("\t\tcall_args[i] = &variant_args[i];")
+            result.append("\t}")
+
+            base = "(GDExtensionTypePtr)&opaque"
+            if "is_static" in method and method["is_static"]:
+                base = "nullptr"
+
+            ret = "nullptr"
+            if need_return:
+                ret = "&ret"
+                result.append(f'\t{correct_type(method["return_type"])} ret;')
+
+            result.append(
+                f"\t_method_bindings.method_{method_name}({base}, reinterpret_cast<GDExtensionConstTypePtr *>(call_args.data()), {ret}, {len(arguments)} + sizeof...(Args));"
+            )
+
+            if need_return:
+                result.append("\treturn ret;")
+
+            result.append("}")
+            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 = []

include/godot_cpp/variant/variant.hpp

@@ -334,6 +334,8 @@ String vformat(const String &p_text, const VarArgs... p_args) {
 	return p_text % args_array;
 }
 
+#include <godot_cpp/variant/builtin_vararg_methods.hpp>
+
 } // namespace godot
 
 #endif // GODOT_VARIANT_HPP