rewrote binding generator in python
Karroffel
parent
3969bcf078
commit
cf30b0f39d
|
|
@ -1,7 +1,8 @@
|
|||
include/godot_cpp/*.hpp
|
||||
include/godot_cpp/impl/
|
||||
include/godot.h
|
||||
include/godot
|
||||
src/*.cpp
|
||||
include/*.hpp
|
||||
*.os
|
||||
*.so
|
||||
*.obj
|
||||
*.pyc
|
||||
*.json
|
||||
bin
|
||||
|
|
|
|||
|
|
@ -3,9 +3,11 @@ import os, subprocess
|
|||
|
||||
|
||||
# Local dependency paths, adapt them to your setup
|
||||
godot_headers_path = "../../godot_headers/"
|
||||
godot_bin_path = "../../godot_fork/bin/"
|
||||
godot_lib_path = "../../godot_fork/bin/"
|
||||
godot_headers_path = "../godot_headers/"
|
||||
godot_bin_path = "../godot_fork/bin/"
|
||||
|
||||
# for windows
|
||||
godot_lib_path = "../godot_fork/bin/"
|
||||
|
||||
|
||||
env = Environment()
|
||||
|
|
@ -30,7 +32,7 @@ if target == "core":
|
|||
if platform == "linux":
|
||||
env.Append(CCFLAGS = ['-g','-O3', '-std=c++14'])
|
||||
|
||||
env.Append(CPPPATH=['.', godot_headers_path])
|
||||
env.Append(CPPPATH=['include/core', godot_headers_path])
|
||||
|
||||
if platform == "windows":
|
||||
env.Append(LIBS=[godot_name + '.lib'])
|
||||
|
|
@ -39,9 +41,9 @@ if target == "core":
|
|||
env.Append(CPPFLAGS=['-D_GD_CPP_CORE_API_IMPL'])
|
||||
|
||||
sources = []
|
||||
add_sources(sources, "godot_cpp/core")
|
||||
add_sources(sources, "src/core")
|
||||
|
||||
library = env.SharedLibrary(target='godot_cpp_core', source=sources)
|
||||
library = env.SharedLibrary(target='bin/godot_cpp_core', source=sources)
|
||||
Default(library)
|
||||
|
||||
|
||||
|
|
@ -61,16 +63,13 @@ elif target == "bindings":
|
|||
|
||||
subprocess.call([godot_executable, '--gdnative-generate-json-api', json_api_file])
|
||||
|
||||
binding_generator_executable = '../binding_generator/target/debug/binding_generator'
|
||||
if platform == "windows":
|
||||
binding_generator_executable += ".exe"
|
||||
# actually create the bindings here
|
||||
|
||||
# TODO Should that be the job of the generator?
|
||||
if not os.path.isdir('godot_cpp/impl'):
|
||||
os.mkdir('godot_cpp/impl')
|
||||
import binding_generator
|
||||
|
||||
|
||||
binding_generator.generate_bindings(json_api_file)
|
||||
|
||||
# Note: the binding generator should have been built before
|
||||
subprocess.call([binding_generator_executable, json_api_file, 'godot_cpp/'])
|
||||
|
||||
if platform == "linux":
|
||||
if env["CXX"] == "clang++":
|
||||
|
|
@ -80,20 +79,20 @@ elif target == "bindings":
|
|||
|
||||
env.Append(CCFLAGS = ['-g','-O3', '-std=c++14'])
|
||||
env.Append(LINKFLAGS = ['-Wl,-R,\'$$ORIGIN\''])
|
||||
env.Append(CPPPATH=['.', godot_headers_path, './godot_cpp'])
|
||||
env.Append(CPPPATH=['.', godot_headers_path, 'include', 'include/core'])
|
||||
|
||||
if platform == "windows":
|
||||
env.Append(LIBS=[godot_name])
|
||||
env.Append(LIBPATH=[godot_lib_path])
|
||||
|
||||
env.Append(LIBS=['godot_cpp_core'])
|
||||
env.Append(LIBPATH=['.'])
|
||||
env.Append(LIBPATH=['bin'])
|
||||
|
||||
env.Append(CPPFLAGS=['-D_GD_CPP_BINDING_IMPL'])
|
||||
|
||||
sources = []
|
||||
add_sources(sources, "godot_cpp/impl/")
|
||||
add_sources(sources, "src")
|
||||
|
||||
library = env.SharedLibrary(target='godot_cpp_bindings', source=sources)
|
||||
library = env.SharedLibrary(target='bin/godot_cpp_bindings', source=sources)
|
||||
Default(library)
|
||||
|
||||
|
|
@ -0,0 +1,623 @@
|
|||
#!python
|
||||
|
||||
import json
|
||||
|
||||
# comment.
|
||||
|
||||
def generate_bindings(path):
|
||||
|
||||
classes = json.load(open(path))
|
||||
|
||||
icalls = set()
|
||||
|
||||
for c in classes:
|
||||
# print c['name']
|
||||
used_classes = get_used_classes(c)
|
||||
|
||||
header = generate_class_header(used_classes, c)
|
||||
|
||||
impl = generate_class_implementation(icalls, used_classes, c)
|
||||
|
||||
header_file = open("include/" + strip_name(c["name"]) + ".hpp", "w+")
|
||||
header_file.write(header)
|
||||
|
||||
source_file = open("src/" + strip_name(c["name"]) + ".cpp", "w+")
|
||||
source_file.write(impl)
|
||||
|
||||
|
||||
icall_header_file = open("src/__icalls.hpp", "w+")
|
||||
icall_header_file.write(generate_icall_header(icalls))
|
||||
|
||||
icall_source_file = open("src/__icalls.cpp", "w+")
|
||||
icall_source_file.write(generate_icall_implementation(icalls))
|
||||
|
||||
|
||||
|
||||
|
||||
def generate_class_header(used_classes, c):
|
||||
|
||||
source = []
|
||||
source.append("#ifndef GODOT_CPP_" + strip_name(c["name"]).upper() + "_HPP")
|
||||
source.append("#define GODOT_CPP_" + strip_name(c["name"]).upper() + "_HPP")
|
||||
source.append("")
|
||||
|
||||
|
||||
source.append("#if defined(_WIN32) && defined(_GD_CPP_BINDING_IMPL)")
|
||||
source.append("# define GD_CPP_BINDING_API __declspec(dllexport)")
|
||||
source.append("#elif defined(_WIN32)")
|
||||
source.append("# define GD_CPP_BINDING_API __declspec(dllimport)")
|
||||
source.append("#else")
|
||||
source.append("# define GD_CPP_BINDING_API")
|
||||
source.append("#endif");
|
||||
source.append("")
|
||||
source.append("")
|
||||
source.append("")
|
||||
source.append("")
|
||||
|
||||
source.append("#include <godot.h>")
|
||||
source.append("")
|
||||
|
||||
|
||||
source.append("#include <CoreTypes.hpp>")
|
||||
|
||||
if c["base_class"] != "":
|
||||
source.append("#include <" + strip_name(c["base_class"]) + ".hpp>")
|
||||
|
||||
|
||||
|
||||
source.append("namespace godot {")
|
||||
source.append("")
|
||||
|
||||
|
||||
for used_type in used_classes:
|
||||
source.append("class " + strip_name(used_type) + ";")
|
||||
|
||||
|
||||
source.append("")
|
||||
|
||||
|
||||
# generate the class definition here
|
||||
source.append("class GD_CPP_BINDING_API " + strip_name(c["name"]) + ("" if c["base_class"] == "" else (" : public " + strip_name(c["base_class"])) ) + " {")
|
||||
|
||||
source.append("public:")
|
||||
source.append("")
|
||||
|
||||
# ___get_class_name
|
||||
source.append("\tstatic inline char *___get_class_name() { return (char *) \"" + strip_name(c["name"]) + "\"; }")
|
||||
|
||||
source.append("\t// constants")
|
||||
|
||||
for name in c["constants"]:
|
||||
source.append("\tconst static int " + name + " = " + str(c["constants"][name]) + ";")
|
||||
|
||||
|
||||
source.append("")
|
||||
source.append("\n\t// methods")
|
||||
|
||||
for method in c["methods"]:
|
||||
|
||||
method_signature = ""
|
||||
|
||||
method_signature += "static " if c["singleton"] else ""
|
||||
method_signature += strip_name(method["return_type"])
|
||||
method_signature += " *" if is_class_type(method["return_type"]) else " "
|
||||
method_signature += escape_cpp(method["name"]) + "("
|
||||
|
||||
|
||||
has_default_argument = False
|
||||
|
||||
for i, argument in enumerate(method["arguments"]):
|
||||
method_signature += "const " + argument["type"] + (" *" if is_class_type(argument["type"]) else " ")
|
||||
method_signature += escape_cpp(argument["name"])
|
||||
|
||||
|
||||
# default arguments
|
||||
def escape_default_arg(_type, default_value):
|
||||
if _type == "Color":
|
||||
return "Color(" + default_value + ")"
|
||||
if _type == "bool" or _type == "int":
|
||||
return default_value.lower()
|
||||
if _type == "Array":
|
||||
return "Array()"
|
||||
if _type in ["PoolVector2Array", "PoolStringArray", "PoolVector3Array", "PoolColorArray"]:
|
||||
return _type + "()"
|
||||
if _type == "Vector2":
|
||||
return "Vector2" + default_value
|
||||
if _type == "Vector3":
|
||||
return "Vector3" + default_value
|
||||
if _type == "Transform":
|
||||
return "Transform()"
|
||||
if _type == "Transform2D":
|
||||
return "Transform2D()"
|
||||
if _type == "Rect2":
|
||||
return "Rect2" + default_value
|
||||
if _type == "Variant":
|
||||
return "Variant()" if default_value == "Null" else default_value
|
||||
if _type == "String":
|
||||
return "\"" + default_value + "\""
|
||||
if _type == "RID":
|
||||
return "RID()"
|
||||
|
||||
if default_value == "Null" or default_value == "[Object:null]":
|
||||
return "nullptr"
|
||||
|
||||
return default_value
|
||||
|
||||
|
||||
|
||||
|
||||
if argument["has_default_value"] or has_default_argument:
|
||||
method_signature += " = " + escape_default_arg(argument["type"], argument["default_value"])
|
||||
has_default_argument = True
|
||||
|
||||
|
||||
|
||||
if i != len(method["arguments"]) - 1:
|
||||
method_signature += ", "
|
||||
|
||||
if method["has_varargs"]:
|
||||
if len(method["arguments"]) > 0:
|
||||
method_signature += ", "
|
||||
method_signature += "const Array& __var_args = Array()"
|
||||
|
||||
method_signature += ")" + (" const" if method["is_const"] and not c["singleton"] else "")
|
||||
|
||||
|
||||
source.append("\t" + method_signature + ";")
|
||||
|
||||
|
||||
source.append("};")
|
||||
source.append("")
|
||||
|
||||
|
||||
source.append("}")
|
||||
source.append("")
|
||||
|
||||
|
||||
|
||||
source.append("#endif")
|
||||
|
||||
|
||||
return "\n".join(source)
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
def generate_class_implementation(icalls, used_classes, c):
|
||||
source = []
|
||||
source.append("#include <" + strip_name(c["name"]) + ".hpp>")
|
||||
source.append("")
|
||||
source.append("")
|
||||
|
||||
source.append("#include <CoreTypes.hpp>")
|
||||
|
||||
source.append("#include <Godot.hpp>")
|
||||
source.append("")
|
||||
|
||||
|
||||
source.append("#include \"__icalls.hpp\"")
|
||||
source.append("")
|
||||
source.append("")
|
||||
|
||||
for used_class in used_classes:
|
||||
source.append("#include <" + strip_name(used_class) + ".hpp>")
|
||||
|
||||
source.append("")
|
||||
source.append("")
|
||||
|
||||
source.append("namespace godot {")
|
||||
|
||||
|
||||
core_object_name = ("___static_object_" + strip_name(c["name"])) if c["singleton"] else "this"
|
||||
|
||||
|
||||
source.append("")
|
||||
source.append("")
|
||||
|
||||
if c["singleton"]:
|
||||
source.append("static godot_object *" + core_object_name + ";")
|
||||
source.append("")
|
||||
source.append("")
|
||||
|
||||
# FIXME Test if inlining has a huge impact on binary size
|
||||
source.append("static inline void ___singleton_init()")
|
||||
source.append("{")
|
||||
source.append("\tif (" + core_object_name + " == nullptr) {")
|
||||
source.append("\t\t" + core_object_name + " = godot_global_get_singleton(\"" + c["name"] + "\");")
|
||||
source.append("\t}")
|
||||
source.append("}")
|
||||
|
||||
source.append("")
|
||||
source.append("")
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
for method in c["methods"]:
|
||||
method_signature = ""
|
||||
|
||||
method_signature += strip_name(method["return_type"])
|
||||
method_signature += " *" if is_class_type(method["return_type"]) else " "
|
||||
method_signature += strip_name(c["name"]) + "::" + escape_cpp(method["name"]) + "("
|
||||
|
||||
for i, argument in enumerate(method["arguments"]):
|
||||
method_signature += "const " + argument["type"] + (" *" if is_class_type(argument["type"]) else " ")
|
||||
method_signature += escape_cpp(argument["name"])
|
||||
|
||||
if i != len(method["arguments"]) - 1:
|
||||
method_signature += ", "
|
||||
|
||||
if method["has_varargs"]:
|
||||
if len(method["arguments"]) > 0:
|
||||
method_signature += ", "
|
||||
method_signature += "const Array& __var_args"
|
||||
|
||||
method_signature += ")" + (" const" if method["is_const"] and not c["singleton"] else "")
|
||||
|
||||
source.append(method_signature + " {")
|
||||
|
||||
|
||||
|
||||
if c["singleton"]:
|
||||
source.append("\t___singleton_init();")
|
||||
|
||||
|
||||
source.append("\tstatic godot_method_bind *mb = NULL;")
|
||||
source.append("\tif (mb == NULL) {")
|
||||
source.append("\t\tmb = godot_method_bind_get_method(\"" + c["name"] +"\", \"" + method["name"] + "\");")
|
||||
source.append("\t}")
|
||||
|
||||
return_statement = ""
|
||||
|
||||
if method["return_type"] != "void":
|
||||
return_statement += "return " + ("(" + strip_name(method["return_type"]) + " *) " if is_class_type(method["return_type"]) else "")
|
||||
|
||||
def get_icall_type_name(name):
|
||||
if is_class_type(name):
|
||||
return "Object"
|
||||
return name
|
||||
|
||||
|
||||
|
||||
if method["is_virtual"] or method["has_varargs"]:
|
||||
|
||||
source.append("\tVariant __given_args[" + str(len(method["arguments"])) + "];")
|
||||
|
||||
for i, argument in enumerate(method["arguments"]):
|
||||
source.append("\tgodot_variant_new_nil((godot_variant *) &__given_args[" + str(i) + "]);")
|
||||
|
||||
source.append("")
|
||||
|
||||
|
||||
for i, argument in enumerate(method["arguments"]):
|
||||
source.append("\t__given_args[" + str(i) + "] = " + escape_cpp(argument["name"]) + ";")
|
||||
|
||||
source.append("")
|
||||
|
||||
size = ""
|
||||
if method["has_varargs"]:
|
||||
size = "(__var_args.size() + " + str(len(method["arguments"])) + ")"
|
||||
else:
|
||||
size = "(" + str(len(method["arguments"])) + ")"
|
||||
|
||||
source.append("\tgodot_variant **__args = (godot_variant **) alloca(sizeof(godot_variant *) * " + size + ");")
|
||||
|
||||
source.append("")
|
||||
|
||||
for i, argument in enumerate(method["arguments"]):
|
||||
source.append("\t__args[" + str(i) + "] = (godot_variant *) &__given_args[" + str(i) + "];")
|
||||
|
||||
source.append("")
|
||||
|
||||
if method["has_varargs"]:
|
||||
source.append("\tfor (int i = 0; i < __var_args.size(); i++) {")
|
||||
source.append("\t\t__args[i + " + str(len(method["arguments"])) + "] = (godot_variant *) &((Array &) __var_args)[i];")
|
||||
source.append("\t}")
|
||||
|
||||
source.append("")
|
||||
|
||||
source.append("\tVariant __result;")
|
||||
source.append("\t*(godot_variant *) &__result = godot_method_bind_call(mb, (godot_object *) " + core_object_name + ", (const godot_variant **) __args, " + size + ", nullptr);")
|
||||
|
||||
source.append("")
|
||||
|
||||
|
||||
for i, argument in enumerate(method["arguments"]):
|
||||
source.append("\tgodot_variant_destroy((godot_variant *) &__given_args[" + str(i) + "]);")
|
||||
|
||||
source.append("")
|
||||
|
||||
if method["return_type"] != "void":
|
||||
cast = ""
|
||||
if is_class_type(method["return_type"]):
|
||||
cast += "(" + strip_name(method["return_type"]) + " *) (Object *) "
|
||||
source.append("\treturn " + cast + "__result;")
|
||||
|
||||
|
||||
|
||||
else:
|
||||
|
||||
args = []
|
||||
for arg in method["arguments"]:
|
||||
args.append(get_icall_type_name(arg["type"]))
|
||||
|
||||
icall_ret_type = get_icall_type_name(method["return_type"])
|
||||
|
||||
icall_sig = tuple((icall_ret_type, tuple(args)))
|
||||
|
||||
icalls.add(icall_sig)
|
||||
|
||||
icall_name = get_icall_name(icall_sig)
|
||||
|
||||
return_statement += icall_name + "(mb, (godot_object *) " + core_object_name
|
||||
|
||||
for arg in method["arguments"]:
|
||||
return_statement += ", " + escape_cpp(arg["name"])
|
||||
|
||||
return_statement += ")"
|
||||
|
||||
source.append("\t" + return_statement + ";")
|
||||
|
||||
source.append("}")
|
||||
source.append("")
|
||||
|
||||
|
||||
|
||||
source.append("}")
|
||||
|
||||
|
||||
return "\n".join(source)
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
def generate_icall_header(icalls):
|
||||
|
||||
source = []
|
||||
source.append("#ifndef GODOT_CPP__ICALLS_HPP")
|
||||
source.append("#define GODOT_CPP__ICALLS_HPP")
|
||||
|
||||
source.append("")
|
||||
|
||||
source.append("#include <godot.h>")
|
||||
source.append("")
|
||||
source.append("")
|
||||
|
||||
source.append("#include <CoreTypes.hpp>")
|
||||
source.append("#include <Object.hpp>")
|
||||
source.append("")
|
||||
source.append("")
|
||||
|
||||
source.append("namespace godot {")
|
||||
source.append("")
|
||||
|
||||
for icall in icalls:
|
||||
ret_type = icall[0]
|
||||
args = icall[1]
|
||||
|
||||
method_signature = ""
|
||||
|
||||
method_signature += return_type(ret_type) + get_icall_name(icall) + "(godot_method_bind *mb, godot_object *inst"
|
||||
|
||||
for arg in args:
|
||||
method_signature += ", const "
|
||||
|
||||
if is_core_type(arg):
|
||||
method_signature += arg + "&"
|
||||
elif is_primitive(arg):
|
||||
method_signature += arg
|
||||
else:
|
||||
method_signature += "Object *"
|
||||
|
||||
method_signature += ");"
|
||||
|
||||
source.append(method_signature)
|
||||
|
||||
source.append("")
|
||||
|
||||
source.append("}")
|
||||
source.append("")
|
||||
|
||||
source.append("#endif")
|
||||
|
||||
return "\n".join(source)
|
||||
|
||||
|
||||
def generate_icall_implementation(icalls):
|
||||
source = []
|
||||
source.append("#include \"__icalls.hpp\"")
|
||||
|
||||
source.append("")
|
||||
|
||||
source.append("#include <godot.h>")
|
||||
source.append("")
|
||||
source.append("")
|
||||
|
||||
source.append("#include <CoreTypes.hpp>")
|
||||
source.append("#include <Object.hpp>")
|
||||
source.append("")
|
||||
source.append("")
|
||||
|
||||
source.append("using namespace godot;")
|
||||
source.append("")
|
||||
|
||||
for icall in icalls:
|
||||
ret_type = icall[0]
|
||||
args = icall[1]
|
||||
|
||||
method_signature = ""
|
||||
|
||||
method_signature += return_type(ret_type) + get_icall_name(icall) + "(godot_method_bind *mb, godot_object *inst"
|
||||
|
||||
for i, arg in enumerate(args):
|
||||
method_signature += ", const "
|
||||
|
||||
if is_core_type(arg):
|
||||
method_signature += arg + "& "
|
||||
elif is_primitive(arg):
|
||||
method_signature += arg + " "
|
||||
else:
|
||||
method_signature += "Object *"
|
||||
|
||||
method_signature += "arg" + str(i)
|
||||
|
||||
method_signature += ")"
|
||||
|
||||
source.append(method_signature + " {")
|
||||
|
||||
if ret_type != "void":
|
||||
source.append("\t" + strip_name(ret_type) + (" *" if is_class_type(ret_type) else " ") + "ret;")
|
||||
if is_class_type(ret_type):
|
||||
source.append("\tret = nullptr;")
|
||||
|
||||
|
||||
source.append("\tconst void *args[" + ("1" if len(args) == 0 else "") + "] = {")
|
||||
|
||||
for i, arg in enumerate(args):
|
||||
|
||||
wrapped_argument = "\t\t"
|
||||
if is_primitive(arg) or is_core_type(arg):
|
||||
wrapped_argument += "(void *) &arg" + str(i)
|
||||
else:
|
||||
wrapped_argument += "(void *) arg" + str(i)
|
||||
|
||||
wrapped_argument += ","
|
||||
source.append(wrapped_argument)
|
||||
|
||||
source.append("\t};")
|
||||
source.append("")
|
||||
|
||||
source.append("\tgodot_method_bind_ptrcall(mb, inst, args, " + ("nullptr" if ret_type == "void" else "&ret") + ");")
|
||||
|
||||
if ret_type != "void":
|
||||
source.append("\treturn ret;")
|
||||
|
||||
source.append("}")
|
||||
|
||||
source.append("")
|
||||
|
||||
return "\n".join(source)
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
def return_type(t):
|
||||
if is_class_type(t):
|
||||
return "Object *"
|
||||
return t + " "
|
||||
|
||||
|
||||
def get_icall_name(sig):
|
||||
ret_type = sig[0]
|
||||
args = sig[1]
|
||||
|
||||
name = "___godot_icall_"
|
||||
name += strip_name(ret_type)
|
||||
for arg in args:
|
||||
name += "_" + strip_name(arg)
|
||||
|
||||
return name
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
def get_used_classes(c):
|
||||
classes = []
|
||||
for method in c["methods"]:
|
||||
if is_class_type(method["return_type"]) and not (method["return_type"] in classes):
|
||||
classes.append(method["return_type"])
|
||||
|
||||
for arg in method["arguments"]:
|
||||
if is_class_type(arg["type"]) and not (arg["type"] in classes):
|
||||
classes.append(arg["type"])
|
||||
return classes
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
def strip_name(name):
|
||||
if name[0] == '_':
|
||||
return name[1:]
|
||||
return name
|
||||
|
||||
|
||||
def is_class_type(name):
|
||||
return not is_core_type(name) and not is_primitive(name)
|
||||
|
||||
def is_core_type(name):
|
||||
core_types = ["Array",
|
||||
"Basis",
|
||||
"Color",
|
||||
"Dictionary",
|
||||
"Error",
|
||||
"Image",
|
||||
"InputEvent",
|
||||
"NodePath",
|
||||
"Plane",
|
||||
"PoolByteArray",
|
||||
"PoolIntArray",
|
||||
"PoolRealArray",
|
||||
"PoolStringArray",
|
||||
"PoolVector2Array",
|
||||
"PoolVector3Array",
|
||||
"PoolColorArray",
|
||||
"Quat",
|
||||
"Rect2",
|
||||
"Rect3",
|
||||
"RID",
|
||||
"String",
|
||||
"Transform",
|
||||
"Transform2D",
|
||||
"Variant",
|
||||
"Vector2",
|
||||
"Vector3"]
|
||||
return name in core_types
|
||||
|
||||
|
||||
|
||||
|
||||
def is_primitive(name):
|
||||
core_types = ["int", "bool", "real", "float", "void"]
|
||||
return name in core_types
|
||||
|
||||
def escape_cpp(name):
|
||||
escapes = {
|
||||
"class": "_class",
|
||||
"char": "_char",
|
||||
"short": "_short",
|
||||
"bool": "_bool",
|
||||
"int": "_int",
|
||||
"default": "_default",
|
||||
"case": "_case",
|
||||
"switch": "_switch",
|
||||
"export": "_export",
|
||||
"template": "_template",
|
||||
"new": "new_"
|
||||
}
|
||||
if name in escapes:
|
||||
return escapes[name]
|
||||
return name
|
||||
|
|
@ -1,4 +0,0 @@
|
|||
target
|
||||
.idea/
|
||||
*.iml
|
||||
Cargo.lock
|
||||
|
|
@ -1,9 +0,0 @@
|
|||
[package]
|
||||
name = "binding_generator"
|
||||
version = "0.1.0"
|
||||
authors = ["karroffel"]
|
||||
|
||||
[dependencies]
|
||||
serde = "*"
|
||||
serde_json = "*"
|
||||
serde_derive = "*"
|
||||
|
|
@ -1,772 +0,0 @@
|
|||
extern crate serde_json;
|
||||
#[macro_use]
|
||||
extern crate serde_derive;
|
||||
|
||||
|
||||
use serde_json::*;
|
||||
use std::fs::File;
|
||||
use std::iter::Iterator;
|
||||
use std::io::prelude::*;
|
||||
|
||||
use std::collections::HashSet;
|
||||
|
||||
use std::env;
|
||||
|
||||
// use std::ascii::AsciiExt;
|
||||
|
||||
#[derive(Deserialize)]
|
||||
struct GodotClass {
|
||||
name: String,
|
||||
base_class: String,
|
||||
api_type: String,
|
||||
singleton: bool,
|
||||
instanciable: bool,
|
||||
is_reference: bool,
|
||||
constants: Map<String, Value>,
|
||||
methods: Vec<GodotMethod>
|
||||
}
|
||||
|
||||
#[derive(Deserialize)]
|
||||
struct GodotMethod {
|
||||
name: String,
|
||||
return_type: String,
|
||||
is_editor: bool,
|
||||
is_noscript: bool,
|
||||
is_const: bool,
|
||||
is_virtual: bool,
|
||||
has_varargs: bool,
|
||||
is_from_script: bool,
|
||||
arguments: Vec<GodotArgument>
|
||||
}
|
||||
|
||||
#[derive(Deserialize)]
|
||||
struct GodotArgument {
|
||||
name: String,
|
||||
#[serde(rename = "type")]
|
||||
_type: String,
|
||||
has_default_value: bool,
|
||||
default_value: String
|
||||
}
|
||||
|
||||
fn strip_name(s: &String) -> &str {
|
||||
if s.starts_with("_") {
|
||||
unsafe { s.slice_unchecked(1, s.len()) }
|
||||
} else {
|
||||
s.as_str()
|
||||
}
|
||||
}
|
||||
|
||||
fn main() {
|
||||
let base_dir = match env::args().nth(2) {
|
||||
Some(x) => x,
|
||||
None => return
|
||||
};
|
||||
|
||||
let mut file = match env::args().nth(1) {
|
||||
Some(x) => File::open(x).unwrap(),
|
||||
None => return
|
||||
};
|
||||
|
||||
let mut file_contents = String::new();
|
||||
|
||||
file.read_to_string(&mut file_contents);
|
||||
|
||||
let json: Vec<GodotClass> = serde_json::from_str::<Vec<GodotClass>>(&file_contents).unwrap();
|
||||
|
||||
let mut icalls: HashSet<(String, Vec<String>)> = HashSet::new();
|
||||
|
||||
for class in &json {
|
||||
// make this toggleable with a command line switch
|
||||
// if class.api_type == "tools" {
|
||||
// println!("{}", class.name);
|
||||
// continue
|
||||
// }
|
||||
let used_classes = get_used_classes(&class);
|
||||
|
||||
let mut header = File::create((base_dir.to_string() + strip_name(&class.name) + ".hpp").as_str()).unwrap();
|
||||
|
||||
header.write_all(generate_class_header(&used_classes, &class).as_bytes());
|
||||
|
||||
let mut implementation = File::create((base_dir.to_string() + "impl/" + strip_name(&class.name) + ".cpp").as_str()).unwrap();
|
||||
implementation.write_all(generate_class_implementation(&mut icalls, &used_classes, &class).as_bytes());
|
||||
}
|
||||
|
||||
// generate icall files
|
||||
let mut icall_header = File::create((base_dir.to_string() + "__icalls.hpp").as_str()).unwrap();
|
||||
|
||||
icall_header.write_all(generate_icall_header(&icalls).as_bytes());
|
||||
|
||||
let mut icall_implmentation = File::create((base_dir.to_string() + "impl/__icalls.cpp").as_str()).unwrap();
|
||||
|
||||
icall_implmentation.write_all(generate_icall_implementation(&json, &icalls).as_bytes());
|
||||
}
|
||||
|
||||
fn get_used_classes(class: &GodotClass) -> HashSet<&String> {
|
||||
|
||||
let mut classes = HashSet::new();
|
||||
|
||||
// classes.insert(&class.base_class);
|
||||
|
||||
for method in &class.methods {
|
||||
if !is_primitive(&method.return_type) &&!is_core_type(&method.return_type) && !classes.contains(&method.return_type) {
|
||||
classes.insert(&method.return_type);
|
||||
}
|
||||
|
||||
for argument in &method.arguments {
|
||||
if !is_primitive(&argument._type) &&!is_core_type(&argument._type) && !classes.contains(&argument._type) {
|
||||
classes.insert(&argument._type);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return classes;
|
||||
}
|
||||
|
||||
fn generate_class_header(used_classes: &HashSet<&String>, class: &GodotClass) -> String {
|
||||
let mut contents = String::new();
|
||||
|
||||
contents = contents + "#ifndef ";
|
||||
contents = contents + strip_name(&class.name).to_string().to_uppercase().as_str() + "_H\n";
|
||||
|
||||
contents = contents + "#define ";
|
||||
contents = contents + strip_name(&class.name).to_string().to_uppercase().as_str() + "_H\n\n";
|
||||
|
||||
contents = contents + "#if defined(_WIN32) && defined(_GD_CPP_BINDING_IMPL)\n";
|
||||
contents = contents + "# define GD_CPP_BINDING_API __declspec(dllexport)\n";
|
||||
contents = contents + "#elif defined(_WIN32)\n";
|
||||
contents = contents + "# define GD_CPP_BINDING_API __declspec(dllimport)\n";
|
||||
contents = contents + "#else\n";
|
||||
contents = contents + "# define GD_CPP_BINDING_API\n";
|
||||
contents = contents + "#endif\n\n";
|
||||
|
||||
|
||||
contents = contents + "\n#include \"core/CoreTypes.hpp\"\n";
|
||||
|
||||
contents = contents + "\n#include <godot.h>\n\n\n";
|
||||
|
||||
if class.base_class != "" {
|
||||
contents = contents + "\n#include \"" + strip_name(&class.base_class) + ".hpp\"\n\n\n";
|
||||
}
|
||||
|
||||
contents = contents + "namespace godot {\n\n";
|
||||
|
||||
// contents += forward_declares;
|
||||
|
||||
for used_type in used_classes {
|
||||
contents = contents + "class " + strip_name(used_type) + ";\n"
|
||||
}
|
||||
|
||||
contents = contents + "\n\n";
|
||||
|
||||
let core_obj_name = {
|
||||
let mut name = String::new();
|
||||
if class.singleton {
|
||||
name = name + "___static_object_" + strip_name(&class.name);
|
||||
} else {
|
||||
name = name + "this";
|
||||
};
|
||||
name
|
||||
};
|
||||
|
||||
contents = contents + "class GD_CPP_BINDING_API " + strip_name(&class.name);
|
||||
|
||||
if class.base_class != "" {
|
||||
contents = contents + " : public " + strip_name(&class.base_class);
|
||||
}
|
||||
|
||||
contents = contents + " {\n";
|
||||
|
||||
// if class.base_class == "" {
|
||||
// contents = contents + "public:\n\tgodot_object *__core_object = 0;\n\n";
|
||||
// }
|
||||
|
||||
if class.singleton {
|
||||
contents = contents + "private:\n";
|
||||
contents = contents + "\tstatic void ___singleton_init();\n";
|
||||
}
|
||||
|
||||
contents = contents + "public:\n\n";
|
||||
|
||||
// default constructor
|
||||
|
||||
{
|
||||
contents = contents + "\tstatic " + strip_name(&class.name) + "* _new();\n\n";
|
||||
}
|
||||
|
||||
|
||||
// pointer constructor
|
||||
// {
|
||||
// contents = contents + "\t" + strip_name(&class.name) + "(godot_object *ptr);\n\n";
|
||||
// }
|
||||
|
||||
// object constructor
|
||||
// if !class.singleton {
|
||||
// contents = contents + "\t" + strip_name(&class.name) + "(const Object *ptr);\n\n";
|
||||
// contents = contents + "\t" + strip_name(&class.name) + "(const Variant& obj);\n\n";
|
||||
// }
|
||||
|
||||
if class.name != "Object" {
|
||||
contents = contents + "\tvoid _init();\n\n";
|
||||
}
|
||||
|
||||
// if class.instanciable {
|
||||
// contents = contents + "\tstatic " + strip_name(&class.name) + " __new();\n";
|
||||
// contents = contents + "\tvoid __destroy();\n\n";
|
||||
// }
|
||||
|
||||
for (name, value) in &class.constants {
|
||||
contents = contents + "\tconst static int " + name.as_str() + " = " + value.as_i64().unwrap().to_string().as_str() + ";\n";
|
||||
}
|
||||
|
||||
contents += "\n\n";
|
||||
|
||||
fn escape_default_arg(type_: &String, arg: &String) -> String {
|
||||
match type_.as_str() {
|
||||
"Color" => {
|
||||
String::from("Color(") + arg.as_str() + ")"
|
||||
},
|
||||
"bool" | "int" => {
|
||||
String::from(arg.as_str()).as_str().to_lowercase()
|
||||
},
|
||||
"Array" => {
|
||||
String::from("Array()")
|
||||
},
|
||||
"PoolVector2Array" | "PoolStringArray" | "PoolColorArray" | "PoolVector3Array" => {
|
||||
type_.clone() + "()" // String::from("PoolVector2Array()")
|
||||
}
|
||||
"Vector2" => {
|
||||
String::from("Vector2") + arg.as_str()
|
||||
}
|
||||
"Vector3" => {
|
||||
String::from("Vector3") + arg.as_str()
|
||||
}
|
||||
"Transform" => {
|
||||
String::from("Transform()")// + arg.as_str() + ")"
|
||||
}
|
||||
"Transform2D" => {
|
||||
String::from("Transform2D()")
|
||||
}
|
||||
"Rect2" => {
|
||||
String::from("Rect2") + arg.as_str()
|
||||
}
|
||||
"Variant" => {
|
||||
if arg == "Null" {
|
||||
String::from("Variant()")
|
||||
} else {
|
||||
arg.clone()
|
||||
}
|
||||
}
|
||||
"String" => {
|
||||
String::from("\"") + arg.as_str() + "\""
|
||||
}
|
||||
"RID" => {
|
||||
String::from("RID()")
|
||||
}
|
||||
_ => {
|
||||
match arg.as_str() {
|
||||
"Null" => String::from("nullptr"),
|
||||
"[Object:null]" => String::from("nullptr"),
|
||||
a => String::from(a)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
for method in &class.methods {
|
||||
contents = contents + "\t" + (if class.singleton { "static " } else { "" }) + strip_name(&method.return_type) + (if !is_core_type(&method.return_type) && !is_primitive(&method.return_type) { " *" } else { " " }) + escape_cpp(&method.name) + "(";
|
||||
|
||||
let mut has_default = false;
|
||||
|
||||
for (i, argument) in (&method.arguments).iter().enumerate() {
|
||||
if !is_primitive(&argument._type) && !is_core_type(&argument._type) {
|
||||
contents = contents + "const " + argument._type.as_str() + " *";
|
||||
} else {
|
||||
contents = contents + "const " + argument._type.as_str() + " ";
|
||||
}
|
||||
|
||||
contents = contents + escape_cpp(&argument.name);
|
||||
|
||||
if argument.has_default_value || has_default {
|
||||
contents = contents + " = " + escape_default_arg(&argument._type, &argument.default_value).as_str();
|
||||
has_default = true;
|
||||
}// else if has_default {
|
||||
// contents = contents + " = \"\"";
|
||||
//}
|
||||
|
||||
if i != method.arguments.len() - 1 {
|
||||
contents += ", ";
|
||||
}
|
||||
}
|
||||
|
||||
if method.has_varargs {
|
||||
if method.arguments.len() > 0 {
|
||||
contents += ", ";
|
||||
}
|
||||
contents = contents + "const Array& __var_args = Array()";
|
||||
}
|
||||
|
||||
contents = contents + ")" + if method.is_const && !class.singleton { " const" } else { "" } + ";\n";
|
||||
// contents = contents + ")" + if method.is_const { " const" } else { "" } + ";\n";
|
||||
}
|
||||
|
||||
contents = contents + "};\n\n";
|
||||
|
||||
// if class.base_class == "" {
|
||||
// // Object
|
||||
// contents = contents + "\ninline\n#if defined(_WIN32)\n# ifdef _GD_CPP_BINDING_IMPL\n __declspec(dllexport)\n# else\n __declspec(dllimport)\n# endif\n#endif\nVariant::operator Object() const\n{\n\n";
|
||||
|
||||
// contents = contents + "\treturn Object(godot_variant_as_object(&_godot_variant));\n\n";
|
||||
|
||||
// contents = contents + "\n}\n\n";
|
||||
// }
|
||||
|
||||
contents = contents + "}\n";
|
||||
|
||||
contents = contents + "#endif\n";
|
||||
|
||||
contents
|
||||
}
|
||||
|
||||
|
||||
fn generate_class_implementation(icalls: &mut HashSet<(String, Vec<String>)>, used_classes: &HashSet<&String>, class: &GodotClass) -> String {
|
||||
let mut contents = String::new();
|
||||
|
||||
contents = contents + "#include \"" + strip_name(&class.name) + ".hpp" + "\"\n";
|
||||
|
||||
contents = contents + "\n#include \"core/CoreTypes.hpp\"\n";
|
||||
|
||||
contents = contents + "\n#include \"Godot.hpp\"\n\n";
|
||||
|
||||
if class.instanciable {
|
||||
contents = contents + "#include \"ClassDB.hpp\"\n";
|
||||
}
|
||||
|
||||
contents = contents + "\n#include \"__icalls.hpp\"\n\n\n";
|
||||
|
||||
for used_class in used_classes {
|
||||
contents = contents + "#include \"" + strip_name(used_class) + ".hpp\"\n";
|
||||
}
|
||||
|
||||
contents = contents + "\n\n";
|
||||
|
||||
contents = contents + "namespace godot {\n\n";
|
||||
|
||||
let core_obj_name = {
|
||||
let mut name = String::new();
|
||||
if class.singleton {
|
||||
name = name + "___static_object_" + strip_name(&class.name);
|
||||
} else {
|
||||
name = name + "this";
|
||||
};
|
||||
name
|
||||
};
|
||||
|
||||
contents = contents + "\n\n\n";
|
||||
|
||||
if class.singleton {
|
||||
contents = contents + "static godot_object *" + core_obj_name.as_str() + ";\n\n\n\n\n";
|
||||
}
|
||||
|
||||
|
||||
if class.singleton {
|
||||
contents = contents + "void " + strip_name(&class.name) + "::___singleton_init()\n{\n\t"
|
||||
+ core_obj_name.as_str() + " = godot_global_get_singleton(\"" + strip_name(&class.name) + "\");\n}\n\n";
|
||||
}
|
||||
|
||||
|
||||
// default constructor
|
||||
|
||||
{
|
||||
contents = contents + strip_name(&class.name) + " *" + strip_name(&class.name) + "::_new()\n{\n";
|
||||
contents = contents + "\tgodot_class_constructor constructor = godot_get_class_constructor(\"" + class.name.as_str() + "\");\n";
|
||||
contents = contents + "\tif (!constructor) { return nullptr; }\n";
|
||||
contents = contents + "\treturn (" + strip_name(&class.name) + " *) constructor();\n";
|
||||
contents = contents + "}\n\n";
|
||||
}
|
||||
|
||||
|
||||
// pointer constructor
|
||||
// {
|
||||
// contents = contents + "" + strip_name(&class.name) + "::" + strip_name(&class.name) + "(godot_object *ptr)\n{\n";
|
||||
// contents = contents + "\t__core_object = ptr;\n";
|
||||
// contents = contents + "}\n\n\n";
|
||||
// }
|
||||
|
||||
// Object constructor
|
||||
// if !class.singleton {
|
||||
// contents = contents + "" + strip_name(&class.name) + "::" + strip_name(&class.name) + "(const Object *ptr)\n{\n";
|
||||
// contents = contents + "\t__core_object = ?;\n";
|
||||
// contents = contents + "}\n\n\n";
|
||||
//
|
||||
// contents = contents + "" + strip_name(&class.name) + "::" + strip_name(&class.name) + "(const Variant& obj)\n{\n";
|
||||
// contents = contents + "\t__core_object = ((Object) obj).__core_object;\n";
|
||||
// contents = contents + "}\n\n\n";
|
||||
// }
|
||||
|
||||
if class.name != "Object" {
|
||||
contents = contents + "void " + strip_name(&class.name) + "::" + "_init()\n{\n";
|
||||
contents = contents + "\t\n";
|
||||
contents = contents + "}\n\n";
|
||||
}
|
||||
|
||||
|
||||
contents += "\n\n";
|
||||
|
||||
for method in &class.methods {
|
||||
contents = contents + strip_name(&method.return_type) + (if !is_core_type(&method.return_type) && !is_primitive(&method.return_type) { " *" } else { " " }) + strip_name(&class.name) + "::" + escape_cpp(&method.name) + "(";
|
||||
|
||||
for (i, argument) in (&method.arguments).iter().enumerate() {
|
||||
if !is_primitive(&argument._type) && !is_core_type(&argument._type) {
|
||||
contents = contents + "const " + argument._type.as_str() + " *";
|
||||
} else {
|
||||
contents = contents + "const " + argument._type.as_str() + " ";
|
||||
}
|
||||
|
||||
contents = contents + escape_cpp(&argument.name);
|
||||
if i != method.arguments.len() - 1 {
|
||||
contents += ", ";
|
||||
}
|
||||
}
|
||||
|
||||
if method.has_varargs {
|
||||
if method.arguments.len() > 0 {
|
||||
contents += ", ";
|
||||
}
|
||||
contents = contents + "const Array& __var_args";
|
||||
}
|
||||
|
||||
contents = contents + ")" + if method.is_const && !class.singleton { " const" } else { "" } + "\n{\n";
|
||||
|
||||
|
||||
if class.singleton {
|
||||
contents = contents + "\tif (" + core_obj_name.as_str() + " == 0) {\n";
|
||||
contents = contents + "\t\t___singleton_init();\n";
|
||||
contents = contents + "\t}\n\n";
|
||||
}
|
||||
|
||||
if method.is_virtual || method.has_varargs {
|
||||
|
||||
contents = contents + "\tArray __args;\n";
|
||||
|
||||
// fill in the args
|
||||
for arg in &method.arguments {
|
||||
contents = contents + "\t__args.append(" + escape_cpp(&arg.name) + ");\n";
|
||||
}
|
||||
|
||||
if method.has_varargs {
|
||||
contents = contents + "\tfor (int i = 0; i < __var_args.size(); i++) {\n";
|
||||
contents = contents + "\t\t__args.append(__var_args[i]);\n";
|
||||
contents = contents + "\t}\n";
|
||||
}
|
||||
|
||||
contents = contents + "\t";
|
||||
|
||||
if method.return_type != "void" {
|
||||
contents = contents + "return ";
|
||||
|
||||
if !is_primitive(&method.return_type) && !is_core_type(&method.return_type) {
|
||||
contents = contents + "(" + strip_name(&method.return_type) + " *) (Object *) ";
|
||||
}
|
||||
}
|
||||
|
||||
contents = contents + "((Object *) " + core_obj_name.as_str() + ")->callv(\"" + method.name.as_str() + "\", __args);\n";
|
||||
} else {
|
||||
contents = contents + "\tstatic godot_method_bind *mb = NULL;\n"
|
||||
+ "\tif (mb == NULL) {\n"
|
||||
+ "\t\tmb = godot_method_bind_get_method(\"" + class.name.as_str() + "\", \"" + method.name.as_str() + "\");\n"
|
||||
+ "\t}\n\t";
|
||||
|
||||
|
||||
if method.return_type != "void" {
|
||||
contents = contents + "return ";
|
||||
if !is_primitive(&method.return_type) && !is_core_type(&method.return_type) {
|
||||
contents = contents + "(" + strip_name(&method.return_type) + " *) ";
|
||||
}
|
||||
}
|
||||
|
||||
let mut args = Vec::new();
|
||||
|
||||
fn get_icall_type_name(t: &String) -> String {
|
||||
if is_core_type(t) || is_primitive(t) {
|
||||
t.clone()
|
||||
} else {
|
||||
String::from("Object")
|
||||
}
|
||||
}
|
||||
|
||||
for arg in &method.arguments {
|
||||
args.push(get_icall_type_name(&arg._type));
|
||||
}
|
||||
|
||||
let icallsig = (get_icall_type_name(&method.return_type), args);
|
||||
|
||||
let name = get_icall_name(&icallsig);
|
||||
|
||||
icalls.insert(icallsig);
|
||||
|
||||
|
||||
contents = contents + name.as_str() + "(mb, (godot_object *) " + core_obj_name.as_str();
|
||||
|
||||
for arg in &method.arguments {
|
||||
contents = contents + ", " + escape_cpp(&arg.name);
|
||||
}
|
||||
|
||||
// if !is_primitive(&method.return_type) && !is_core_type(&method.return_type) {
|
||||
// contents = contents + ")";
|
||||
// }
|
||||
contents = contents + ");\n";
|
||||
}
|
||||
|
||||
contents = contents + "}\n\n";
|
||||
}
|
||||
|
||||
// if class.instanciable {
|
||||
|
||||
// contents = contents + strip_name(&class.name) + " " + strip_name(&class.name) + "::__new() {\n";
|
||||
// contents = contents + "\tObject ptr = ClassDB::instance(\"" + class.name.as_str() + "\");\n";
|
||||
// contents = contents + "\treturn ptr;\n";
|
||||
// contents = contents + "}\n\n";
|
||||
|
||||
// contents = contents + "void " + strip_name(&class.name) + "::__destroy() {\n";
|
||||
// contents = contents + "\tgodot_object_destroy(__core_object);\n";
|
||||
// contents = contents + "}\n\n\n";
|
||||
|
||||
/* if class.base_class == "" {
|
||||
// Object
|
||||
contents = contents + "Variant::operator Object()const {\n\n";
|
||||
|
||||
contents = contents + "\treturn Object(godot_variant_as_object(&_godot_variant));\n\n";
|
||||
|
||||
contents = contents + "}\n\n";
|
||||
} */
|
||||
// }
|
||||
|
||||
contents = contents + "}\n";
|
||||
|
||||
contents
|
||||
}
|
||||
|
||||
fn get_icall_name(sig: &(String, Vec<String>)) -> String {
|
||||
|
||||
let &(ref ret, ref args) = sig;
|
||||
|
||||
let mut name = String::new();
|
||||
|
||||
name = name + "___godot_icall_";
|
||||
|
||||
name = name + strip_name(&ret);
|
||||
|
||||
for arg in args {
|
||||
name = name + "_" + strip_name(&arg);
|
||||
}
|
||||
|
||||
name
|
||||
}
|
||||
|
||||
fn get_icall_name_ref(sig: (&String, &Vec<String>)) -> String {
|
||||
|
||||
let (ref ret, args) = sig;
|
||||
|
||||
let mut name = String::new();
|
||||
|
||||
name = name + "___godot_icall_";
|
||||
|
||||
name = name + strip_name(&ret);
|
||||
|
||||
for arg in args {
|
||||
name = name + "_" + strip_name(&arg);
|
||||
}
|
||||
|
||||
name
|
||||
}
|
||||
|
||||
fn generate_icall_header(icalls: &HashSet<(String, Vec<String>)>) -> String {
|
||||
|
||||
fn return_type(t: &String) -> String {
|
||||
if is_primitive(t) || is_core_type(t) {
|
||||
t.clone()
|
||||
} else {
|
||||
String::from("Object *")
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
let mut contents = String::new();
|
||||
|
||||
contents = contents + "#ifndef __ICALLS_H\n";
|
||||
contents = contents + "#define __ICALLS_H\n\n\n";
|
||||
|
||||
contents = contents + "#include <godot.h>\n\n\n";
|
||||
|
||||
contents = contents + "#include \"core/CoreTypes.hpp\"\n";
|
||||
contents = contents + "#include \"Object.hpp\"\n\n\n";
|
||||
|
||||
|
||||
|
||||
contents = contents + "using namespace godot;\n\n\n";
|
||||
|
||||
for &(ref ret, ref args) in icalls {
|
||||
contents = contents + return_type(ret).as_str() + " " + get_icall_name_ref((ret, args)).as_str() + "(godot_method_bind *mb, godot_object *inst";
|
||||
for arg in args {
|
||||
contents = contents + ", ";
|
||||
if is_core_type(&arg) {
|
||||
// if !is_primitive(&arg) {
|
||||
contents = contents + "const " + arg.as_str() + "& ";
|
||||
} else if is_primitive(&arg) {
|
||||
contents = contents + "const " + arg.as_str() + " ";
|
||||
} else {
|
||||
contents = contents + "const Object *";
|
||||
}
|
||||
}
|
||||
contents = contents + ");\n";
|
||||
}
|
||||
|
||||
contents = contents + "#endif";
|
||||
|
||||
contents
|
||||
}
|
||||
|
||||
fn generate_icall_implementation(class_api: &Vec<GodotClass>, icalls: &HashSet<(String, Vec<String>)>) -> String {
|
||||
|
||||
fn return_type(t: &String) -> String {
|
||||
if is_primitive(t) || is_core_type(t) {
|
||||
t.clone()
|
||||
} else {
|
||||
let s = String::new() + t.as_str() + " *";
|
||||
s
|
||||
}
|
||||
}
|
||||
|
||||
let is_reference = |name: &String| {
|
||||
for class in class_api {
|
||||
if class.name.as_str() == name.as_str() {
|
||||
return class.is_reference;
|
||||
}
|
||||
}
|
||||
false
|
||||
};
|
||||
|
||||
let mut contents = String::new();
|
||||
|
||||
contents = contents + "#include \"__icalls.hpp\"\n";
|
||||
|
||||
contents = contents + "#include <godot.h>\n\n\n";
|
||||
|
||||
contents = contents + "#include \"core/CoreTypes.hpp\"\n";
|
||||
contents = contents + "#include \"Object.hpp\"\n\n\n";
|
||||
|
||||
contents = contents + "using namespace godot;\n\n\n";
|
||||
|
||||
for &(ref ret, ref args) in icalls {
|
||||
contents = contents + return_type(ret).as_str() + " " + get_icall_name_ref((ret, args)).as_str() + "(godot_method_bind *mb, godot_object *inst";
|
||||
let mut i = 0;
|
||||
for arg in args {
|
||||
contents = contents + ", ";
|
||||
if is_core_type(&arg) {
|
||||
// if !is_primitive(&arg) {
|
||||
contents = contents + "const " + arg.as_str() + "& ";
|
||||
} else if is_primitive(&arg) {
|
||||
contents = contents + "const " + arg.as_str() + " ";
|
||||
} else {
|
||||
contents = contents + "const " + arg.as_str() + " *";
|
||||
}
|
||||
contents = contents + "arg" + i.to_string().as_str();
|
||||
i = i + 1;
|
||||
}
|
||||
contents = contents + ")\n";
|
||||
|
||||
contents = contents + "{\n";
|
||||
|
||||
if ret != "void" {
|
||||
contents = contents + "\t" + strip_name(ret) + if !is_core_type(ret) && !is_primitive(ret) { " *" } else { "" } + " ret;\n";
|
||||
if !is_core_type(ret) && !is_primitive(ret) {
|
||||
contents = contents + "\t" + "ret = nullptr;\n";
|
||||
}
|
||||
}
|
||||
|
||||
contents = contents + "\tconst void *args[" + if args.len() == 0 { "1" } else { "" } + "] = {\n";
|
||||
|
||||
let mut j = 0;
|
||||
for arg in args {
|
||||
contents = contents + "\t\t";
|
||||
if is_primitive(arg) {
|
||||
contents = contents + "&arg" + j.to_string().as_str();
|
||||
} else if is_core_type(arg) {
|
||||
contents = contents + "(void *) &arg" + j.to_string().as_str();
|
||||
} else {
|
||||
contents = contents + "(void *) arg" + j.to_string().as_str();
|
||||
}
|
||||
contents = contents + ",\n";
|
||||
j = j + 1;
|
||||
}
|
||||
|
||||
contents = contents + "\t};\n";
|
||||
|
||||
contents = contents + "\tgodot_method_bind_ptrcall(mb, inst, args, " + if ret == "void" { "NULL" } else { "&ret" } + ");\n";
|
||||
|
||||
if !is_primitive(ret) && !is_core_type(ret) {
|
||||
contents = contents + "\treturn ret;\n";
|
||||
} else if ret != "void" {
|
||||
contents = contents + "\treturn ret;\n";
|
||||
}
|
||||
|
||||
contents = contents + "}\n\n";
|
||||
}
|
||||
|
||||
// contents = contents + "#endif";
|
||||
|
||||
contents
|
||||
}
|
||||
|
||||
|
||||
fn is_core_type(name: &String) -> bool {
|
||||
let core_types = vec!["Array",
|
||||
"Basis",
|
||||
"Color",
|
||||
"Dictionary",
|
||||
"Error",
|
||||
"Image",
|
||||
"InputEvent",
|
||||
"NodePath",
|
||||
"Plane",
|
||||
"PoolByteArray",
|
||||
"PoolIntArray",
|
||||
"PoolRealArray",
|
||||
"PoolStringArray",
|
||||
"PoolVector2Array",
|
||||
"PoolVector3Array",
|
||||
"PoolColorArray",
|
||||
"Quat",
|
||||
"Rect2",
|
||||
"Rect3",
|
||||
"RID",
|
||||
"String",
|
||||
"Transform",
|
||||
"Transform2D",
|
||||
"Variant",
|
||||
"Vector2",
|
||||
"Vector3"];
|
||||
core_types.contains(&name.as_str())
|
||||
}
|
||||
|
||||
fn is_primitive(name: &String) -> bool {
|
||||
let core_types = vec!["int", "bool", "real", "float", "void"];
|
||||
core_types.contains(&name.as_str())
|
||||
}
|
||||
|
||||
fn escape_cpp(name: &String) -> &str {
|
||||
match name.as_str() {
|
||||
"class" => "_class",
|
||||
"char" => "_char",
|
||||
"short" => "_short",
|
||||
"bool" => "_bool",
|
||||
"int" => "_int",
|
||||
"default" => "_default",
|
||||
"case" => "_case",
|
||||
"switch" => "_switch",
|
||||
"export" => "_export",
|
||||
"template" => "_template",
|
||||
"new" => "new_",
|
||||
x => x
|
||||
}
|
||||
}
|
||||
|
|
@ -6,10 +6,10 @@
|
|||
#include <godot.h>
|
||||
|
||||
|
||||
#include <godot_cpp/core/CoreTypes.hpp>
|
||||
#include <godot_cpp/core/Variant.hpp>
|
||||
#include <CoreTypes.hpp>
|
||||
#include <Variant.hpp>
|
||||
|
||||
#include <godot_cpp/Object.hpp>
|
||||
#include <Object.hpp>
|
||||
|
||||
namespace godot {
|
||||
|
||||
Loading…
Reference in New Issue