buuunch of stuff

.gitignore

@@ -2,3 +2,4 @@ include/godot_cpp/*.hpp
 include/godot_cpp/impl/
 include/godot.h
 include/godot
+*.os

binding_generator/src/main.rs

@@ -68,6 +68,8 @@ fn main() {
 
 	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 {
 		let used_classes = get_used_classes(&class);
 
@@ -76,8 +78,17 @@ fn main() {
 		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(&used_classes, &class).as_bytes());
+		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(&icalls).as_bytes());
 }
 
 fn get_used_classes(class: &GodotClass) -> HashSet<&String> {
@@ -110,12 +121,12 @@ fn generate_class_header(used_classes: &HashSet<&String>, class: &GodotClass) ->
 	contents = contents + "#define ";
 	contents = contents + strip_name(&class.name).to_string().to_uppercase().as_str() + "_H\n\n";
 
-	contents = contents + "\n#include \"core/CoreTypes.h\"\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) + ".h\"\n\n\n";
+		contents = contents + "\n#include \"" + strip_name(&class.base_class) + ".hpp\"\n\n\n";
 	}
 
 	contents = contents + "namespace godot {\n\n";
@@ -138,10 +149,6 @@ fn generate_class_header(used_classes: &HashSet<&String>, class: &GodotClass) ->
 		name
 	};
 
-	if class.singleton {
-		contents = contents + "\n\nstatic godot_object *" + core_obj_name.as_str() + ";\n\n";
-	}
-
 	contents = contents + "class " + strip_name(&class.name);
 
 	if class.base_class != "" {
@@ -178,8 +185,8 @@ fn generate_class_header(used_classes: &HashSet<&String>, class: &GodotClass) ->
 	}
 
 	if class.instanciable {
-		contents = contents + "\tstatic " + strip_name(&class.name) + " _new();\n";
-		contents = contents + "\tvoid _destroy();\n\n";
+		contents = contents + "\tstatic " + strip_name(&class.name) + "& __new();\n";
+		contents = contents + "\tvoid __destroy();\n\n";
 	}
 
 	for (name, value) in &class.constants {
@@ -189,7 +196,7 @@ fn generate_class_header(used_classes: &HashSet<&String>, class: &GodotClass) ->
 	contents += "\n\n";
 
 	for method in &class.methods {
-		contents = contents + "\t" + (if class.singleton { "static " } else if method.is_virtual { "virtual " } else { "" }) + strip_name(&method.return_type) + (if !is_core_type(&method.return_type) && !is_primitive(&method.return_type) { " &" } else { " " }) + method.name.as_str() + "(";
+		contents = contents + "\t" + (if class.singleton { "static " } else if method.is_virtual { "virtual " } else { "" }) + strip_name(&method.return_type) + (if !is_core_type(&method.return_type) && !is_primitive(&method.return_type) { " &" } else { " " }) + escape_cpp(&method.name) + "(";
 
 		for (i, argument) in (&method.arguments).iter().enumerate() {
 			if !is_primitive(&argument._type) {
@@ -204,11 +211,21 @@ fn generate_class_header(used_classes: &HashSet<&String>, class: &GodotClass) ->
 			}
 		}
 
-		contents = contents + ")" + if method.is_const { " const" } else { "" } + ";\n";
+		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 Variant::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";
@@ -217,22 +234,26 @@ fn generate_class_header(used_classes: &HashSet<&String>, class: &GodotClass) ->
 }
 
 
-fn generate_class_implementation(used_classes: &HashSet<&String>, class: &GodotClass) -> String {
+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.h\"\n";
+	contents = contents + "\n#include \"core/CoreTypes.hpp\"\n";
 
-	contents = contents + "\n#include <godot.h>\n\n\n";
+	if class.instanciable {
+		contents = contents + "#include \"ClassDB.hpp\"\n";
+	}
 
-	if class.base_class != "" {
-		contents = contents + "\n#include \"" + strip_name(&class.base_class) + ".h\"\n\n\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 + "namespace godot {\n\n";
+	contents = contents + "\n\n";
 
-	// contents += forward_declares;
+	contents = contents + "namespace godot {\n\n";
 
 	let core_obj_name = {
 		let mut name = String::new();
@@ -244,65 +265,46 @@ fn generate_class_implementation(used_classes: &HashSet<&String>, class: &GodotC
 		name
 	};
 
-	if class.singleton {
-		contents = contents + "\n\nstatic godot_object *" + core_obj_name.as_str() + ";\n\n";
-	}
+	contents = contents + "\n\n\n";
 
-	contents = contents + "\n\n\nclass " + strip_name(&class.name);
-
-	if class.base_class != "" {
-		contents = contents + " : public " + strip_name(&class.base_class);
+	if class.singleton {
+		contents = contents + "static godot_object *" + core_obj_name.as_str() + ";\n\n\n\n\n";
 	}
 
-	contents = contents + " {\n";
-
-	if class.base_class == "" {
-		contents = contents + "protected:\n\tgodot_object *__core_object = 0;\n\n";
-	}
 
 	if class.singleton {
-		contents = contents + "private:\n";
-		contents = contents + "\tstatic void ___singleton_init() { "
-			+ core_obj_name.as_str() + " = godot_global_get_singleton(\"" + strip_name(&class.name) + "\"); }\n\n";
+		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";
 	}
 
-	contents = contents + "public:\n\n";
 
 	// default constructor
 
 	{
-		contents = contents + "\t" + strip_name(&class.name) + "() {\n";
-		contents = contents + "\t\t\n";
-		contents = contents + "\t}\n\n";
+		contents = contents + "" + strip_name(&class.name) + "::" + strip_name(&class.name) + "()\n{\n";
+		contents = contents + "\t\n";
+		contents = contents + "}\n\n";
 	}
 
 
 	// pointer constructor
 	{
-		contents = contents + "\t" + strip_name(&class.name) + "(godot_object *ptr) {\n";
-		contents = contents + "\t\t__core_object = ptr;\n";
-		contents = contents + "\t}\n\n\n";
+		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";
 	}
 
 	if class.base_class != "" {
-		contents = contents + "\tvoid _init() {\n";
-		contents = contents + "\t\t\n";
-		contents = contents + "\t}\n\n";
+		contents = contents + "void " + strip_name(&class.name) + "::" + "_init()\n{\n";
+		contents = contents + "\t\n";
+		contents = contents + "}\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";
 
 	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 { " " }) + method.name.as_str() + "(";
+		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) {
@@ -317,94 +319,269 @@ fn generate_class_implementation(used_classes: &HashSet<&String>, class: &GodotC
 			}
 		}
 
-		contents = contents + ") {\n";
+		contents = contents + ")" + if method.is_const && !class.singleton { " const" } else { "" } + "\n{\n";
+
 
 		if class.singleton {
-			contents = contents + "\t\tif (" + core_obj_name.as_str() + " == 0) {\n";
-			contents = contents + "\t\t\t___singleton_init();\n";
-			contents = contents + "\t\t}\n\n";
+			contents = contents + "\tif (" + core_obj_name.as_str() + " == 0) {\n";
+			contents = contents + "\t\t___singleton_init();\n";
+			contents = contents + "\t}\n\n";
 		}
 
-		contents = contents + "\t\tstatic godot_method_bind *mb = NULL;\n"
-			+ "\t\tif (mb == NULL) {\n"
-			+ "\t\t\tmb = godot_method_bind_get_method(\"" + class.name.as_str() + "\", \"" + method.name.as_str() + "\");\n"
-			+ "\t\t}\n";
+		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 + "\t\t" + strip_name(&method.return_type) + (if !is_core_type(&method.return_type) && !is_primitive(&method.return_type) { "*" } else { "" }) + " ret;" + "\n";
-			contents = contents + "\t\t" + if !is_core_type(&method.return_type) && !is_primitive(&method.return_type) { "godot_object*" } else { strip_name(&method.return_type) } + " ret;\n";
+			contents = contents + "return ";
+			if !is_primitive(&method.return_type) && !is_core_type(&method.return_type) {
+				contents = contents + "reinterpret_cast<" + strip_name(&method.return_type) + "&>(";
+			}
 		}
 
-		contents = contents + "\t\tconst void *args[] = {\n";
+		let mut args = Vec::new();
 
-		for argument in &method.arguments {
-			contents = contents + "\t\t\t";
-			if is_primitive(&argument._type) {
-				contents = contents + "&" + argument.name.as_str();
-			} else if is_core_type(&argument._type) {
-				contents = contents + "(void *) &" + escape_cpp(&argument.name);
+		fn get_icall_type_name(t: &String) -> String {
+			if is_core_type(t) || is_primitive(t) {
+				t.clone()
 			} else {
-				contents = contents + "(void *) &" + escape_cpp(&argument.name);
+				"Object".to_string()
 			}
-			contents = contents + ",\n";
 		}
 
-		contents = contents + "\t\t};\n";
+		for arg in &method.arguments {
+			args.push(get_icall_type_name(&arg._type));
+		}
 
-		contents = contents + "\t\tgodot_method_bind_ptrcall(mb, " + core_obj_name.as_str() + ", args, " + if method.return_type == "void" { "NULL" } else { "&ret" } + ");\n";
+		let icallsig = (get_icall_type_name(&method.return_type), args);
 
-		if !is_primitive(&method.return_type) && !is_core_type(&method.return_type) {
-			contents = contents + "\t\treturn reinterpret_cast<" + strip_name(&method.return_type) + "&>(ret);\n";
-		} else if method.return_type != "void" {
-			contents = contents + "\t\treturn ret;\n";
-		}
+		let name = get_icall_name(&icallsig);
 
-		contents = contents + "\t}\n\n";
-	}
+		icalls.insert(icallsig);
 
-	contents = contents + "};\n\n";
 
-	contents = contents + "}\n";
 
+		contents = contents + name.as_str() + "(mb, " + core_obj_name.as_str();
 
+		for arg in &method.arguments {
+			contents = contents + ", " + escape_cpp(&arg.name);
+		}
 
-	if class.instanciable {
+		if !is_primitive(&method.return_type) && !is_core_type(&method.return_type) {
+			contents = contents + ")";
+		}
+		contents = contents + ");\n";
 
-		contents = contents + "#include \"ClassDB.h\"\n";
+		contents = contents + "}\n\n";
+	}
 
-		contents = contents + "namespace godot {\n\n";
+	if class.instanciable {
 
-		contents = contents + "" + strip_name(&class.name) + "& " + strip_name(&class.name) + "::_new() {\n";
+		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 reinterpret_cast<" + strip_name(&class.name) + "&>(ptr);";
+		contents = contents + "\treturn reinterpret_cast<" + strip_name(&class.name) + "&>(ptr);\n";
 		contents = contents + "}\n\n";
 
-		contents = contents + "void " + strip_name(&class.name) + "::_destroy() {\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 == "" {
+		/* 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) -> &str {
+		if is_primitive(t) || is_core_type(t) {
+			t.as_str()
+		} else {
+			"Object& "
 		}
+	}
+
+
+	let mut contents = String::new();
+
+	contents = contents + "#ifndef __ICALLS_H\n";
+	contents = contents + "#define __ICALLS_H\n\n\n";
 
-		contents = contents + "}\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) + " " + get_icall_name_ref((ret, args)).as_str() + "(godot_method_bind *mb, godot_object *inst";
+		for arg in args {
+			contents = contents + ", ";
+			if !is_primitive(&arg) {
+				contents = contents + "const " + arg.as_str() + "&";
+			} else {
+				contents = contents + "const " + arg.as_str() + "";
+			}
+		}
+		contents = contents + ");\n";
 	}
 
+	contents = contents + "#endif";
 
+	contents
+}
+
+fn generate_icall_implementation(icalls: &HashSet<(String, Vec<String>)>) -> String {
+
+	fn return_type(t: &String) -> &str {
+		if is_primitive(t) || is_core_type(t) {
+			t.as_str()
+		} else {
+			"Object& "
+		}
+	}
+
+	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) + " " + 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_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" + if !is_core_type(ret) && !is_primitive(ret) { "godot_object*" } else { strip_name(ret) } + " ret;\n";
+		}
+
+		contents = contents + "\tconst void *args[] = {\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 reinterpret_cast<Object&>(ret);\n";
+		} else if ret != "void" {
+			contents = contents + "\treturn ret;\n";
+		}
+
+		contents = contents + "}\n\n";
+	}
+
+	// contents = contents + "#endif";
 
-	contents = contents + "#endif\n";
-	*/
 	contents
 }
 
 
 fn is_core_type(name: &String) -> bool {
-	let core_types = vec!["Array", "PoolStringArray", "Vector2", "Vector3", "String", "Variant"];
+	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())
 }
 
@@ -418,6 +595,14 @@ fn escape_cpp(name: &String) -> &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
 	}
 }

include/SConstruct

@@ -1,31 +1,51 @@
 #!python
+import os
+
 env = Environment()
 env["CXX"] = "clang++"
-env.Append(CCFLAGS = ['-g','-O3', '-std=c++14'])
-env.Append(CPPPATH=['.', './godot'])
-
-sources = [
-	'godot_cpp/core/Array.cpp',
-	'godot_cpp/core/Basis.cpp',
-	'godot_cpp/core/Color.cpp',
-	'godot_cpp/core/Dictionary.cpp',
-	'godot_cpp/core/Image.cpp',
-	'godot_cpp/core/InputEvent.cpp',
-	'godot_cpp/core/NodePath.cpp',
-	'godot_cpp/core/Plane.cpp',
-	'godot_cpp/core/PoolArrays.cpp',
-	'godot_cpp/core/Quat.cpp',
-	'godot_cpp/core/Rect2.cpp',
-	'godot_cpp/core/Rect3.cpp',
-	'godot_cpp/core/RID.cpp',
-	'godot_cpp/core/String.cpp',
-	'godot_cpp/core/Transform.cpp',
-	'godot_cpp/core/Transform2D.cpp',
-	'godot_cpp/core/Variant.cpp',
-	'godot_cpp/core/Vector2.cpp',
-	'godot_cpp/core/Vector3.cpp'
-]
-
-library = env.SharedLibrary(target='godot_cpp_core', source=sources)
-Default(library)
+
+target = ARGUMENTS.get("target", "core")
+
+if (target == "core"):
+    env.Append(CCFLAGS = ['-g','-O3', '-std=c++14'])
+    env.Append(CPPPATH=['.', './godot'])
+
+    sources = [
+        'godot_cpp/core/Array.cpp',
+        'godot_cpp/core/Basis.cpp',
+        'godot_cpp/core/Color.cpp',
+        'godot_cpp/core/Dictionary.cpp',
+        'godot_cpp/core/Image.cpp',
+        'godot_cpp/core/InputEvent.cpp',
+        'godot_cpp/core/NodePath.cpp',
+        'godot_cpp/core/Plane.cpp',
+        'godot_cpp/core/PoolArrays.cpp',
+        'godot_cpp/core/Quat.cpp',
+        'godot_cpp/core/Rect2.cpp',
+        'godot_cpp/core/Rect3.cpp',
+        'godot_cpp/core/RID.cpp',
+        'godot_cpp/core/String.cpp',
+        'godot_cpp/core/Transform.cpp',
+        'godot_cpp/core/Transform2D.cpp',
+        'godot_cpp/core/Variant.cpp',
+        'godot_cpp/core/Vector2.cpp',
+        'godot_cpp/core/Vector3.cpp'
+    ]
+
+    library = env.SharedLibrary(target='godot_cpp_core', source=sources)
+    Default(library)
+
+elif target == "binding":
+    env.Append(CCFLAGS = ['-Wno-writable-strings'])
+    env.Append(CCFLAGS = ['-g','-O3', '-std=c++14'])
+    env.Append(CPPPATH=['.', './godot', './godot_cpp'])
+
+    env.Append(RPATH=['.'])
+    env.Append(LINKFLAGS=['-Rgodot_cpp_core'])
+
+
+    sources = [os.path.join("godot_cpp/impl/", f) for f in os.listdir("godot_cpp/impl/") if f.endswith('.cpp')]
+
+    library = env.SharedLibrary(target='godot_cpp_bindings', source=sources)
+    Default(library)
 

include/godot_cpp/Godot.h

@@ -1,267 +0,0 @@
-#ifndef GODOT_H
-#define GODOT_H
-
-#include <cstdlib>
-
-#include <godot.h>
-
-
-#include <godot_cpp/core/CoreTypes.h>
-#include <godot_cpp/core/Variant.h>
-
-namespace godot {
-
-
-#define GODOT_CLASS(Name, Base) \
-	public: static char *___get_type_name() { return (char *) #Name; } \
-	static char *___get_base_type_name() { return (char *) #Base; } \
-	Name(godot_object *o) { __core_object = o; } \
-	private:
-
-
-
-template<class A, class B>
-A object_cast(B b)
-{
-	A *a = (A*) &b;
-	return *a;
-}
-
-
-
-
-
-// instance and destroy funcs
-
-template<class T>
-void *_godot_class_instance_func(godot_object *p)
-{
-	T *d = new T(p);
-	d->_init();
-	return d;
-}
-
-template<class T>
-void _godot_class_destroy_func(godot_object *p, void *data)
-{
-	T *d = (T *) data;
-	delete d;
-}
-
-
-
-template<class T>
-void register_class()
-{
-	godot_script_register(T::___get_type_name(), T::___get_base_type_name(), _godot_class_instance_func<T>, _godot_class_destroy_func<T>);
-	T::_register_methods();
-}
-
-
-
-
-
-
-// wrapped methods
-
-template<class T, class R, class A0, class A1, class A2, class A3, class A4, R (T::*p)(A0, A1, A2, A3, A4)>
-struct WrappedMethod5 {
-	static godot_variant wrapped_method(godot_object *_, void *data, int num_args, godot_variant **args)
-	{
-		godot_variant _variant;
-		godot_variant_new_nil(&_variant);
-		godot::Variant *v = (godot::Variant *) &_variant;
-		T *obj = (T *) data;
-		godot::Variant **arg = (godot::Variant **) args;
-		*v = (obj->*p)(*arg[0], *arg[1], *arg[2], *arg[3], *arg[4]);
-		return _variant;
-	}
-};
-
-template<class T, class A0, class A1, class A2, class A3, class A4, void (T::*p)(A0, A1, A2, A3, A4)>
-struct WrappedMethod5<T, void, A0, A1, A2, A3, A4, p> {
-	static godot_variant wrapped_method(godot_object *_, void *data, int num_args, godot_variant **args)
-	{
-		godot_variant _variant;
-		godot_variant_new_nil(&_variant);
-		T *obj = (T *) data;
-		godot::Variant **arg = (godot::Variant **) args;
-		(obj->*p)(*arg[0], *arg[1], *arg[2], *arg[3], *arg[4]);
-		return _variant;
-	}
-};
-
-template<class T, class R, class A0, class A1, class A2, class A3, R (T::*p)(A0, A1, A2, A3)>
-struct WrappedMethod4 {
-	static godot_variant wrapped_method(godot_object *_, void *data, int num_args, godot_variant **args)
-	{
-		godot_variant _variant;
-		godot_variant_new_nil(&_variant);
-		godot::Variant *v = (godot::Variant *) &_variant;
-		T *obj = (T *) data;
-		godot::Variant **arg = (godot::Variant **) args;
-		*v = (obj->*p)(*arg[0], *arg[1], *arg[2], *arg[3]);
-		return _variant;
-	}
-};
-
-template<class T, class A0, class A1, class A2, class A3, void (T::*p)(A0, A1, A2, A3)>
-struct WrappedMethod4<T, void, A0, A1, A2, A3, p> {
-	static godot_variant wrapped_method(godot_object *_, void *data, int num_args, godot_variant **args)
-	{
-		godot_variant _variant;
-		godot_variant_new_nil(&_variant);
-		T *obj = (T *) data;
-		godot::Variant **arg = (godot::Variant **) args;
-		(obj->*p)(*arg[0], *arg[1], *arg[2], *arg[3]);
-		return _variant;
-	}
-};
-
-
-template<class T, class R, class A0, class A1, class A2, R (T::*p)(A0, A1, A2)>
-struct WrappedMethod3 {
-	static godot_variant wrapped_method(godot_object *_, void *data, int num_args, godot_variant **args)
-	{
-		godot_variant _variant;
-		godot_variant_new_nil(&_variant);
-		godot::Variant *v = (godot::Variant *) &_variant;
-		T *obj = (T *) data;
-		godot::Variant **arg = (godot::Variant **) args;
-		*v = (obj->*p)(*arg[0], *arg[1], *arg[2]);
-		return _variant;
-	}
-};
-
-template<class T, class A0, class A1, class A2, void (T::*p)(A0, A1, A2)>
-struct WrappedMethod3<T, void, A0, A1, A2, p> {
-	static godot_variant wrapped_method(godot_object *_, void *data, int num_args, godot_variant **args)
-	{
-		godot_variant _variant;
-		godot_variant_new_nil(&_variant);
-		T *obj = (T *) data;
-		godot::Variant **arg = (godot::Variant **) args;
-		(obj->*p)(*arg[0], *arg[1], *arg[2]);
-		return _variant;
-	}
-};
-
-template<class T, class R, class A0, class A1, R (T::*p)(A0, A1)>
-struct WrappedMethod2 {
-	static godot_variant wrapped_method(godot_object *_, void *data, int num_args, godot_variant **args)
-	{
-		godot_variant _variant;
-		godot_variant_new_nil(&_variant);
-		godot::Variant *v = (godot::Variant *) &_variant;
-		T *obj = (T *) data;
-		godot::Variant **arg = (godot::Variant **) args;
-		*v = (obj->*p)(*arg[0], *arg[1]);
-		return _variant;
-	}
-};
-
-template<class T, class A0, class A1, void (T::*p)(A0, A1)>
-struct WrappedMethod2<T, void, A0, A1, p> {
-	static godot_variant wrapped_method(godot_object *_, void *data, int num_args, godot_variant **args)
-	{
-		godot_variant _variant;
-		godot_variant_new_nil(&_variant);
-		T *obj = (T *) data;
-		godot::Variant **arg = (godot::Variant **) args;
-		(obj->*p)(*arg[0], *arg[1]);
-		return _variant;
-	}
-};
-
-template<class T, class R, class I, R (T::*p)(I)>
-struct WrappedMethod1 {
-	static godot_variant wrapped_method(godot_object *_, void *data, int num_args, godot_variant **args)
-	{
-		godot_variant _variant;
-		godot_variant_new_nil(&_variant);
-		godot::Variant *v = (godot::Variant *) &_variant;
-		T *obj = (T *) data;
-		godot::Variant **arg = (godot::Variant **) args;
-		*v = (obj->*p)(*arg[0]);
-		return _variant;
-	}
-};
-
-template <class T, class I, void (T::*p)(I)>
-struct WrappedMethod1<T, void, I, p> {
-	static godot_variant wrapped_method(godot_object *_, void *data, int num_args, godot_variant **args)
-	{
-		godot_variant _variant;
-		godot_variant_new_nil(&_variant);
-		T *obj = (T *) data;
-		godot::Variant **arg = (godot::Variant **) args;
-		(obj->*p)(*arg[0]);
-		return _variant;
-	}
-};
-
-
-
-template<class T, class R, R (T::*p)()>
-struct WrappedMethod0 {
-	static godot_variant wrapped_method(godot_object *_, void *data, int num_args, godot_variant **args)
-	{
-		godot_variant _variant;
-		godot_variant_new_nil(&_variant);
-		godot::Variant *v = (godot::Variant *) &_variant;
-		T *obj = (T *) data;
-		*v = (obj->*p)();
-		return _variant;
-	}
-};
-
-template<class T, void (T::*p)()>
-struct WrappedMethod0<T, void, p> {
-	static godot_variant wrapped_method(godot_object *_, void *data, int num_args, godot_variant **args)
-	{
-		godot_variant _variant;
-		godot_variant_new_nil(&_variant);
-		T *obj = (T *) data;
-		(obj->*p)();
-		return _variant;
-	}
-};
-
-// method registering
-
-
-template<class T, class R, R (T::*p)()>
-void register_method(char *name, godot_method_attributes attr = {}) {
-	godot_script_add_method(T::___get_type_name(), name, &attr, &WrappedMethod0<T, R, p>::wrapped_method);
-}
-
-template<class T, class R, class A0, R (T::*p)(A0)>
-void register_method(char *name, godot_method_attributes attr = {}) {
-	godot_script_add_method(T::___get_type_name(), name, &attr, &WrappedMethod1<T, R, A0, p>::wrapped_method);
-}
-
-template<class T, class R, class A0, class A1, R (T::*p)(A0, A1)>
-void register_method(char *name, godot_method_attributes attr = {}) {
-	godot_script_add_method(T::___get_type_name(), name, &attr, &WrappedMethod2<T, R, A0, A1, p>::wrapped_method);
-}
-
-template<class T, class R, class A0, class A1, class A2, R (T::*p)(A0, A1, A2)>
-void register_method(char *name, godot_method_attributes attr = {}) {
-	godot_script_add_method(T::___get_type_name(), name, &attr, &WrappedMethod3<T, R, A0, A1, A2, p>::wrapped_method);
-}
-
-template<class T, class R, class A0, class A1, class A2, class A3, R (T::*p)(A0, A1, A2, A3)>
-void register_method(char *name, godot_method_attributes attr = {}) {
-	godot_script_add_method(T::___get_type_name(), name, &attr, &WrappedMethod4<T, R, A0, A1, A2, A3, p>::wrapped_method);
-}
-
-
-template<class T, class R, class A0, class A1, class A2, class A3, class A4, R (T::*p)(A0, A1, A2, A3, A4)>
-void register_method(char *name, godot_method_attributes attr = {}) {
-	godot_script_add_method(T::___get_type_name(), name, &attr, &WrappedMethod5<T, R, A0, A1, A2, A3, A4, p>::wrapped_method);
-}
-
-
-}
-
-#endif // GODOT_H

include/godot_cpp/core/Array.cpp

@@ -1,10 +1,10 @@
-#include "Array.h"
+#include "Array.hpp"
 
 #include <cstdlib>
 
 #include <godot/godot_array.h>
 
-#include "Variant.h"
+#include "Variant.hpp"
 
 namespace godot {
 

include/godot_cpp/core/Array.h → include/godot_cpp/core/Array.hpp

@@ -3,7 +3,7 @@
 
 #include <godot/godot_array.h>
 
-#include "String.h"
+#include "String.hpp"
 
 namespace godot {
 

include/godot_cpp/core/Basis.cpp

@@ -1,11 +1,11 @@
-#include "Basis.h"
+#include "Basis.hpp"
 
 
-#include "Defs.h"
+#include "Defs.hpp"
 
-#include "Vector3.h"
+#include "Vector3.hpp"
 
-#include "Quat.h"
+#include "Quat.hpp"
 
 #include <algorithm>
 
@@ -597,7 +597,7 @@ Basis::Basis(const Vector3& p_euler) {
 
 }
 
-#include "Quat.h"
+#include "Quat.hpp"
 
 namespace godot {
 

include/godot_cpp/core/Basis.h → include/godot_cpp/core/Basis.hpp

@@ -1,9 +1,9 @@
 #ifndef BASIS_H
 #define BASIS_H
 
-#include "Defs.h"
+#include "Defs.hpp"
 
-#include "Vector3.h"
+#include "Vector3.hpp"
 
 namespace godot {
 

include/godot_cpp/core/Color.cpp

@@ -1,10 +1,10 @@
-#include "Color.h"
+#include "Color.hpp"
 
 #include <godot/godot_color.h>
 
 #include <cmath>
 
-#include "String.h"
+#include "String.hpp"
 
 namespace godot {
 

include/godot_cpp/core/Color.h → include/godot_cpp/core/Color.hpp

@@ -5,7 +5,7 @@
 
 #include <cmath>
 
-#include "String.h"
+#include "String.hpp"
 
 namespace godot {
 

include/godot_cpp/core/CoreTypes.h

@@ -1,27 +0,0 @@
-#ifndef CORETYPES_H
-#define CORETYPES_H
-
-#include "Defs.h"
-
-#include "Array.h"
-#include "Basis.h"
-#include "Color.h"
-#include "Dictionary.h"
-#include "Image.h"
-#include "InputEvent.h"
-#include "NodePath.h"
-#include "Plane.h"
-#include "PoolArrays.h"
-#include "Quat.h"
-#include "Rect2.h"
-#include "Rect3.h"
-#include "RID.h"
-#include "String.h"
-#include "Transform.h"
-#include "Transform2D.h"
-#include "Variant.h"
-#include "Vector2.h"
-#include "Vector3.h"
-
-
-#endif // CORETYPES_H

include/godot_cpp/core/CoreTypes.hpp

@@ -0,0 +1,27 @@
+#ifndef CORETYPES_H
+#define CORETYPES_H
+
+#include "Defs.hpp"
+
+#include "Array.hpp"
+#include "Basis.hpp"
+#include "Color.hpp"
+#include "Dictionary.hpp"
+#include "Image.hpp"
+#include "InputEvent.hpp"
+#include "NodePath.hpp"
+#include "Plane.hpp"
+#include "PoolArrays.hpp"
+#include "Quat.hpp"
+#include "Rect2.hpp"
+#include "Rect3.hpp"
+#include "RID.hpp"
+#include "String.hpp"
+#include "Transform.hpp"
+#include "Transform2D.hp"
+#include "Variant.hpp"
+#include "Vector2.hpp"
+#include "Vector3.hpp"
+
+
+#endif // CORETYPES_H

include/godot_cpp/core/Dictionary.cpp

@@ -1,8 +1,8 @@
-#include "Dictionary.h"
+#include "Dictionary.hpp"
 
-#include "Variant.h"
+#include "Variant.hpp"
 
-#include "Array.h"
+#include "Array.hpp"
 
 #include <godot/godot_dictionary.h>
 

include/godot_cpp/core/Dictionary.h → include/godot_cpp/core/Dictionary.hpp

@@ -1,9 +1,9 @@
 #ifndef DICTIONARY_H
 #define DICTIONARY_H
 
-#include "Variant.h"
+#include "Variant.hpp"
 
-#include "Array.h"
+#include "Array.hpp"
 
 #include <godot/godot_dictionary.h>
 

include/godot_cpp/core/Image.cpp

@@ -1,13 +1,13 @@
-#include "Image.h"
+#include "Image.hpp"
 
-#include "Defs.h"
+#include "Defs.hpp"
 
-#include "Vector2.h"
-#include "Rect2.h"
-#include "Color.h"
-#include "String.h"
+#include "Vector2.hpp"
+#include "Rect2.hpp"
+#include "Color.hpp"
+#include "String.hpp"
 
-#include "PoolArrays.h"
+#include "PoolArrays.hpp"
 
 #include <godot/godot_image.h>
 

include/godot_cpp/core/Image.h → include/godot_cpp/core/Image.hpp

@@ -1,12 +1,12 @@
 #ifndef IMAGE_H
 #define IMAGE_H
 
-#include "Defs.h"
+#include "Defs.hpp"
 
-#include "Vector2.h"
-#include "Rect2.h"
-#include "Color.h"
-#include "String.h"
+#include "Vector2.hpp"
+#include "Rect2.hpp"
+#include "Color.hpp"
+#include "String.hpp"
 
 #include <godot/godot_image.h>
 

include/godot_cpp/core/InputEvent.cpp

@@ -1,14 +1,14 @@
-#include "InputEvent.h"
+#include "InputEvent.hpp"
 
 #include <cstdint>
 #include <memory.h>
 
-#include "Vector2.h"
-#include "Transform2D.h"
+#include "Vector2.hpp"
+#include "Transform2D.hp"
 
 #include <cmath>
 
-#include "String.h"
+#include "String.hpp"
 
 namespace godot {
 

include/godot_cpp/core/InputEvent.h → include/godot_cpp/core/InputEvent.hpp

@@ -4,7 +4,7 @@
 #include <cstdint>
 #include <memory.h>
 
-#include "String.h"
+#include "String.hpp"
 
 namespace godot {
 

include/godot_cpp/core/NodePath.cpp

@@ -1,6 +1,6 @@
-#include "NodePath.h"
+#include "NodePath.hpp"
 
-#include "String.h"
+#include "String.hpp"
 
 #include <godot/godot_node_path.h>
 

include/godot_cpp/core/NodePath.h → include/godot_cpp/core/NodePath.hpp

@@ -1,7 +1,7 @@
 #ifndef NODEPATH_H
 #define NODEPATH_H
 
-#include "String.h"
+#include "String.hpp"
 
 #include <godot/godot_node_path.h>
 

include/godot_cpp/core/Plane.cpp

@@ -1,6 +1,6 @@
-#include "Plane.h"
+#include "Plane.hpp"
 
-#include "Vector3.h"
+#include "Vector3.hpp"
 
 #include <cmath>
 

include/godot_cpp/core/Plane.h → include/godot_cpp/core/Plane.hpp

@@ -1,7 +1,7 @@
 #ifndef PLANE_H
 #define PLANE_H
 
-#include "Vector3.h"
+#include "Vector3.hpp"
 
 #include <cmath>
 

include/godot_cpp/core/PoolArrays.cpp

@@ -1,11 +1,11 @@
-#include "PoolArrays.h"
+#include "PoolArrays.hpp"
 
-#include "Defs.h"
+#include "Defs.hpp"
 
-#include "String.h"
-#include "Color.h"
-#include "Vector2.h"
-#include "Vector3.h"
+#include "String.hpp"
+#include "Color.hpp"
+#include "Vector2.hpp"
+#include "Vector3.hpp"
 
 #include <godot/godot_pool_arrays.h>
 

include/godot_cpp/core/PoolArrays.h → include/godot_cpp/core/PoolArrays.hpp

@@ -1,12 +1,12 @@
 #ifndef POOLARRAYS_H
 #define POOLARRAYS_H
 
-#include "Defs.h"
+#include "Defs.hpp"
 
-#include "String.h"
-#include "Color.h"
-#include "Vector2.h"
-#include "Vector3.h"
+#include "String.hpp"
+#include "Color.hpp"
+#include "Vector2.hpp"
+#include "Vector3.hpp"
 
 #include <godot/godot_pool_arrays.h>
 

include/godot_cpp/core/Quat.cpp

@@ -1,13 +1,13 @@
-#include "Quat.h"
+#include "Quat.hpp"
 
 
 #include <cmath>
 
-#include "Defs.h"
+#include "Defs.hpp"
 
-#include "Vector3.h"
+#include "Vector3.hpp"
 
-#include "Basis.h"
+#include "Basis.hpp"
 
 namespace godot {
 

include/godot_cpp/core/Quat.h → include/godot_cpp/core/Quat.hpp

@@ -3,7 +3,7 @@
 
 #include <cmath>
 
-#include "Vector3.h"
+#include "Vector3.hpp"
 
 // #include "Basis.h"
 

include/godot_cpp/core/RID.cpp

@@ -1,4 +1,4 @@
-#include "RID.h"
+#include "RID.hpp"
 
 #include <godot/godot_rid.h>
 

include/godot_cpp/core/RID.h → include/godot_cpp/core/RID.hpp

@@ -11,6 +11,8 @@ class RID {
 	godot_rid _godot_rid;
 public:
 
+	inline RID() {}
+
 	RID(Object *p);
 
 	int32_t get_rid() const;

include/godot_cpp/core/Rect2.cpp

@@ -1,12 +1,12 @@
-#include "Rect2.h"
+#include "Rect2.hpp"
 
-#include "Vector2.h"
+#include "Vector2.hpp"
 
-#include "String.h"
+#include "String.hpp"
 
 #include <cmath>
 
-#include "Transform2D.h"
+#include "Transform2D.hp"
 
 namespace godot {
 

include/godot_cpp/core/Rect2.h → include/godot_cpp/core/Rect2.hpp

@@ -1,7 +1,7 @@
 #ifndef RECT2_H
 #define RECT2_H
 
-#include "Vector2.h"
+#include "Vector2.hpp"
 
 #include <cmath>
 

include/godot_cpp/core/Rect3.cpp

@@ -1,8 +1,8 @@
-#include "Rect3.h"
+#include "Rect3.hpp"
 
-#include "Vector3.h"
+#include "Vector3.hpp"
 
-#include "Plane.h"
+#include "Plane.hpp"
 
 #include <algorithm>
 

include/godot_cpp/core/Rect3.h → include/godot_cpp/core/Rect3.hpp

@@ -1,9 +1,9 @@
 #ifndef RECT3_H
 #define RECT3_H
 
-#include "Vector3.h"
+#include "Vector3.hpp"
 
-#include "Plane.h"
+#include "Plane.hpp"
 
 #include <cstdlib>
 

include/godot_cpp/core/String.cpp

@@ -1,4 +1,4 @@
-#include "String.h"
+#include "String.hpp"
 
 namespace godot {
 

include/godot_cpp/core/Transform.cpp

@@ -1,11 +1,11 @@
-#include "Transform.h"
+#include "Transform.hpp"
 
-#include "Basis.h"
+#include "Basis.hpp"
 
-#include "Plane.h"
-#include "Rect3.h"
+#include "Plane.hpp"
+#include "Rect3.hpp"
 
-#include "Quat.h"
+#include "Quat.hpp"
 
 namespace godot {
 

include/godot_cpp/core/Transform.h → include/godot_cpp/core/Transform.hpp

@@ -1,10 +1,10 @@
 #ifndef TRANSFORM_H
 #define TRANSFORM_H
 
-#include "Basis.h"
+#include "Basis.hpp"
 
-#include "Plane.h"
-#include "Rect3.h"
+#include "Plane.hpp"
+#include "Rect3.hpp"
 
 namespace godot {
 

include/godot_cpp/core/Transform2D.cpp

@@ -1,10 +1,10 @@
-#include "Transform2D.h"
+#include "Transform2D.hp"
 
-#include "Vector2.h"
+#include "Vector2.hpp"
 
-#include "String.h"
+#include "String.hpp"
 
-#include "Rect2.h"
+#include "Rect2.hpp"
 
 #include <algorithm>
 

include/godot_cpp/core/Transform2D.h → include/godot_cpp/core/Transform2D.hp

@@ -1,7 +1,7 @@
 #ifndef TRANSFORM2D_H
 #define TRANSFORM2D_H
 
-#include "Vector2.h"
+#include "Vector2.hpp"
 
 
 namespace godot {

include/godot_cpp/core/Variant.cpp

@@ -1,10 +1,10 @@
-#include "Variant.h"
+#include "Variant.hpp"
 
 #include <godot/godot_variant.h>
 
-#include "Defs.h"
+#include "Defs.hpp"
 
-#include "CoreTypes.h"
+#include "CoreTypes.hpp"
 
 #include <iostream>
 

include/godot_cpp/core/Variant.h → include/godot_cpp/core/Variant.hpp

@@ -3,24 +3,24 @@
 
 #include <godot/godot_variant.h>
 
-#include "Defs.h"
-
-#include "Basis.h"
-#include "Color.h"
-#include "Image.h"
-#include "InputEvent.h"
-#include "NodePath.h"
-#include "Plane.h"
-#include "PoolArrays.h"
-#include "Quat.h"
-#include "Rect2.h"
-#include "Rect3.h"
-#include "RID.h"
-#include "String.h"
-#include "Transform.h"
-#include "Transform2D.h"
-#include "Vector2.h"
-#include "Vector3.h"
+#include "Defs.hpp"
+
+#include "Basis.hpp"
+#include "Color.hpp"
+#include "Image.hpp"
+#include "InputEvent.hpp"
+#include "NodePath.hpp"
+#include "Plane.hpp"
+#include "PoolArrays.hpp"
+#include "Quat.hpp"
+#include "Rect2.hpp"
+#include "Rect3.hpp"
+#include "RID.hpp"
+#include "String.hpp"
+#include "Transform.hpp"
+#include "Transform2D.hp"
+#include "Vector2.hpp"
+#include "Vector3.hpp"
 
 #include <iostream>
 

include/godot_cpp/core/Vector2.cpp

@@ -1,10 +1,10 @@
-#include "Vector2.h"
+#include "Vector2.hpp"
 
 #include <cmath>
 
 #include <godot/godot_vector2.h>
 
-#include "String.h"
+#include "String.hpp"
 
 namespace godot {
 

include/godot_cpp/core/Vector2.h → include/godot_cpp/core/Vector2.hpp

@@ -4,7 +4,7 @@
 
 #include <godot/godot_vector2.h>
 
-#include "Defs.h"
+#include "Defs.hpp"
 
 namespace godot {
 

include/godot_cpp/core/Vector3.cpp

@@ -1,13 +1,13 @@
-#include "Vector3.h"
+#include "Vector3.hpp"
 
-#include "String.h"
+#include "String.hpp"
 
 #include <stdlib.h>
 
 #include <cmath>
 
 
-#include "Basis.h"
+#include "Basis.hpp"
 
 namespace godot {
 

include/godot_cpp/core/Vector3.h → include/godot_cpp/core/Vector3.hpp

@@ -1,9 +1,9 @@
 #ifndef VECTOR3_H
 #define VECTOR3_H
 
-#include "Defs.h"
+#include "Defs.hpp"
 
-#include "String.h"
+#include "String.hpp"
 
 namespace godot {