Add separate crate which handles command-line interaction with Godot engine

Author: Bromeon

godot-codegen/Cargo.toml

@@ -8,17 +8,15 @@ keywords = ["gamedev", "godot", "engine", "codegen"]
 categories = ["game-engines", "graphics"]
 
 [features]
+default = []
 codegen-fmt = []
 codegen-full = []
 double-precision = []
+custom-godot = ["godot-input/custom-godot"]
 
 [dependencies]
-quote = "1"
-proc-macro2 = "1"
-which = "4"
+godot-input = { path = "../godot-input" }
 heck = "0.4"
-
-# Version >= 1.5.5 for security: https://blog.rust-lang.org/2022/03/08/cve-2022-24713.html
-# 'unicode-gencat' needed for \d, see: https://docs.rs/regex/1.5.5/regex/#unicode-features
-regex = { version = "1.5.5", default-features = false, features = ["std", "unicode-gencat"] }
 nanoserde = "0.1.29"
+proc-macro2 = "1"
+quote = "1"

godot-codegen/input/gdextension_interface.h

@@ -8,8 +8,6 @@
 #![allow(dead_code)]
 #![allow(clippy::question_mark)] // in #[derive(DeJson)]
 
-use crate::{godot_exe, StopWatch};
-
 use nanoserde::DeJson;
 
 // ----------------------------------------------------------------------------------------------------------------------------------------------
@@ -218,7 +216,7 @@ impl MethodReturn {
 // ----------------------------------------------------------------------------------------------------------------------------------------------
 // Implementation
 
-pub fn load_extension_api(watch: &mut StopWatch) -> (ExtensionApi, &'static str) {
+pub fn load_extension_api(watch: &mut godot_input::StopWatch) -> (ExtensionApi, &'static str) {
     // For float/double inference, see:
     // * https://github.com/godotengine/godot-proposals/issues/892
     // * https://github.com/godotengine/godot-cpp/pull/728
@@ -227,9 +225,11 @@ pub fn load_extension_api(watch: &mut StopWatch) -> (ExtensionApi, &'static str)
     #[cfg(not(feature = "double-precision"))]
     let build_config = "float_64"; // TODO infer this
 
-    let json: String = godot_exe::load_extension_api_json(watch);
+    // Use type inference, so we can accept both String (dynamically resolved) and &str (prebuilt).
+    let json = godot_input::load_gdextension_json(watch);
 
-    let model: ExtensionApi = DeJson::deserialize_json(&json).expect("failed to deserialize JSON");
+    let model: ExtensionApi =
+        DeJson::deserialize_json(json.as_str()).expect("failed to deserialize JSON");
     watch.record("deserialize_json");
 
     (model, build_config)

godot-codegen/src/api_parser.rs

@@ -8,12 +8,9 @@ mod api_parser;
 mod central_generator;
 mod class_generator;
 mod context;
-mod godot_exe;
-mod godot_version;
 mod special_cases;
 mod util;
 mod utilities_generator;
-mod watch;
 
 #[cfg(test)]
 mod tests;
@@ -25,22 +22,19 @@ use central_generator::{
 };
 use class_generator::{generate_builtin_class_files, generate_class_files};
 use context::Context;
-use util::ident;
+use util::{ident, to_pascal_case, to_snake_case};
 use utilities_generator::generate_utilities_file;
-use watch::StopWatch;
 
-use crate::util::{to_pascal_case, to_snake_case};
 use proc_macro2::{Ident, TokenStream};
 use quote::{quote, ToTokens};
 use std::path::{Path, PathBuf};
 
-pub fn generate_sys_files(sys_gen_path: &Path) {
+pub fn generate_sys_files(sys_gen_path: &Path, watch: &mut godot_input::StopWatch) {
     let mut out_files = vec![];
-    let mut watch = StopWatch::start();
 
     generate_sys_mod_file(sys_gen_path, &mut out_files);
 
-    let (api, build_config) = load_extension_api(&mut watch);
+    let (api, build_config) = load_extension_api(watch);
     let mut ctx = Context::build_from_api(&api);
     watch.record("build_context");
 
@@ -49,12 +43,11 @@ pub fn generate_sys_files(sys_gen_path: &Path) {
 
     rustfmt_if_needed(out_files);
     watch.record("rustfmt");
-    watch.write_stats_to(&sys_gen_path.join("codegen-stats.txt"));
 }
 
 pub fn generate_core_files(core_gen_path: &Path) {
     let mut out_files = vec![];
-    let mut watch = StopWatch::start();
+    let mut watch = godot_input::StopWatch::start();
 
     generate_core_mod_file(core_gen_path, &mut out_files);
 

godot-codegen/src/lib.rs

@@ -13,6 +13,7 @@ trace = []
 codegen-fmt = ["godot-ffi/codegen-fmt"]
 codegen-full = ["godot-codegen/codegen-full"]
 double-precision = ["godot-codegen/double-precision"]
+custom-godot = ["godot-ffi/custom-godot", "godot-codegen/custom-godot"]
 
 [dependencies]
 godot-ffi = { path = "../godot-ffi" }

godot-core/Cargo.toml

@@ -7,15 +7,14 @@ license = "MPL-2.0"
 keywords = ["gamedev", "godot", "engine", "ffi"]
 categories = ["game-engines", "graphics"]
 
-# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
-
 [features]
+custom-godot = ["dep:godot-input"]
 codegen-fmt = ["godot-codegen/codegen-fmt"]
 #codegen-full = ["godot-codegen/codegen-full"]
 
 [dependencies]
 paste = "1"
 
 [build-dependencies]
-bindgen = { version = "0.63.0", default-features = false, features = ["runtime"] }
+godot-input = { optional = true, path = "../godot-input" }
 godot-codegen = { path = "../godot-codegen" }

godot-ffi/Cargo.toml

@@ -4,105 +4,22 @@
  * file, You can obtain one at https://mozilla.org/MPL/2.0/.
  */
 
-use std::env;
 use std::path::Path;
 
 fn main() {
-    // For custom path on macOS, iOS, Android etc: see gdnative-sys/build.rs
-    let gen_path = Path::new(concat!(env!("CARGO_MANIFEST_DIR"), "/src/gen/"));
+    let mut watch = godot_input::StopWatch::start();
 
+    let gen_path = Path::new(concat!(env!("CARGO_MANIFEST_DIR"), "/src/gen/"));
     if gen_path.exists() {
         std::fs::remove_dir_all(gen_path).unwrap_or_else(|e| panic!("failed to delete dir: {e}"));
+        watch.record("delete_gen_dir");
     }
+    std::fs::create_dir_all(gen_path).unwrap_or_else(|e| panic!("failed to create dir: {e}"));
 
-    run_bindgen(&gen_path.join("gdextension_interface.rs"));
-    godot_codegen::generate_sys_files(gen_path);
-}
-
-fn run_bindgen(out_file: &Path) {
-    let header_path = "../godot-codegen/input/gdextension_interface.h";
-    println!("cargo:rerun-if-changed={header_path}");
-
-    let builder = bindgen::Builder::default()
-        .header(header_path)
-        // Tell cargo to invalidate the built crate whenever any of the
-        // included header files changed.
-        .parse_callbacks(Box::new(bindgen::CargoCallbacks))
-        .prepend_enum_name(false);
-
-    std::fs::create_dir_all(
-        out_file
-            .parent()
-            .expect("bindgen output file has parent dir"),
-    )
-    .expect("create bindgen output dir");
-
-    let bindings = configure_platform_specific(builder)
-        .generate()
-        .expect("failed generate gdextension_interface.h bindings");
-
-    // Write the bindings to the $OUT_DIR/bindings.rs file.
-    bindings
-        .write_to_file(out_file)
-        .expect("failed write gdextension_interface.h bindings to file");
-}
-
-//#[cfg(target_os = "macos")]
-fn configure_platform_specific(builder: bindgen::Builder) -> bindgen::Builder {
-    let target_vendor = env::var("CARGO_CFG_TARGET_VENDOR").unwrap();
-    if target_vendor == "apple" {
-        eprintln!("Build selected for macOS.");
-        let path = env::var("LLVM_PATH").expect("env var 'LLVM_PATH' not set");
-
-        builder
-            .clang_arg("-I")
-            // .clang_arg(format!("{path}/include"))
-            .clang_arg(apple_include_path().expect("apple include path"))
-            .clang_arg("-L")
-            .clang_arg(format!("{path}/lib"))
-    } else {
-        eprintln!("Build selected for Linux/Windows.");
-        builder
-    }
-}
-
-fn apple_include_path() -> Result<String, std::io::Error> {
-    use std::process::Command;
-
-    let target = std::env::var("TARGET").unwrap();
-    let platform = if target.contains("apple-darwin") {
-        "macosx"
-    } else if target == "x86_64-apple-ios" || target == "aarch64-apple-ios-sim" {
-        "iphonesimulator"
-    } else if target == "aarch64-apple-ios" {
-        "iphoneos"
-    } else {
-        panic!("not building for macOS or iOS");
-    };
+    let rust_header_path = gen_path.join("gdextension_interface.rs");
+    let header = godot_input::load_gdextension_rust_header(&rust_header_path, &mut watch);
+    std::fs::write(rust_header_path, header).expect("failed to write extension header");
 
-    // run `xcrun --sdk iphoneos --show-sdk-path`
-    let output = Command::new("xcrun")
-        .args(["--sdk", platform, "--show-sdk-path"])
-        .output()?
-        .stdout;
-    let prefix = std::str::from_utf8(&output)
-        .expect("invalid output from `xcrun`")
-        .trim_end();
-
-    let suffix = "usr/include";
-    let directory = format!("{prefix}/{suffix}");
-
-    Ok(directory)
+    godot_codegen::generate_sys_files(gen_path, &mut watch);
+    watch.write_stats_to(&gen_path.join("godot-ffi-stats.txt"));
 }
-
-// #[cfg(not(target_os = "macos"))]
-// fn configure_platform_specific(builder: Builder) -> Builder {
-//     println!("Build selected for Linux/Windows.");
-//     builder
-// }
-
-/*fn rerun_if_any_changed(paths: &Vec<PathBuf>){
-    for path in paths {
-        println!("cargo:rerun-if-changed={}", path.display());
-    }
-}*/

godot-ffi/build.rs

@@ -0,0 +1,20 @@
+[package]
+name = "godot-input"
+version = "0.1.0"
+edition = "2021"
+rust-version = "1.63"
+license = "MPL-2.0"
+keywords = ["gamedev", "godot", "engine", "ffi", "sys"]
+categories = ["game-engines", "graphics"]
+
+[features]
+custom-godot = ["dep:bindgen", "dep:regex", "dep:which"]
+
+[dependencies]
+godot4-artifacts = { git = "https://github.com/godot-rust/godot4-artifacts", branch = "4.0" }
+
+# Version >= 1.5.5 for security: https://blog.rust-lang.org/2022/03/08/cve-2022-24713.html
+# 'unicode-gencat' needed for \d, see: https://docs.rs/regex/1.5.5/regex/#unicode-features
+bindgen = { optional = true, version = "0.64", default-features = false, features = ["runtime"] }
+regex = { optional = true, version = "1.5.5", default-features = false, features = ["std", "unicode-gencat"] }
+which = { optional = true, version = "4" }

godot-input/Cargo.toml

@@ -5,20 +5,19 @@
  */
 
 use crate::godot_version::parse_godot_version;
-use crate::StopWatch;
+use crate::header_gen::run_bindgen;
+use crate::watch::StopWatch;
 use std::path::{Path, PathBuf};
 use std::process::Command;
 
 /// Commands related to Godot executable
 
-const GODOT_VERSION_PATH: &str =
-    concat!(env!("CARGO_MANIFEST_DIR"), "/input/gen/godot_version.txt");
+const GODOT_VERSION_PATH: &str = concat!(env!("CARGO_MANIFEST_DIR"), "/gen/godot_version.txt");
+const JSON_PATH: &str = concat!(env!("CARGO_MANIFEST_DIR"), "/gen/extension_api.json");
+const HEADER_PATH: &str = concat!(env!("CARGO_MANIFEST_DIR"), "/gen/gdextension_interface.h");
 
-const EXTENSION_API_PATH: &str =
-    concat!(env!("CARGO_MANIFEST_DIR"), "/input/gen/extension_api.json");
-
-pub fn load_extension_api_json(watch: &mut StopWatch) -> String {
-    let json_path = Path::new(EXTENSION_API_PATH);
+pub fn load_gdextension_json(watch: &mut StopWatch) -> String {
+    let json_path = Path::new(JSON_PATH);
     rerun_on_changed(json_path);
 
     let godot_bin = locate_godot_binary();
@@ -31,15 +30,43 @@ pub fn load_extension_api_json(watch: &mut StopWatch) -> String {
         dump_extension_api(&godot_bin, json_path);
         update_version_file(&version);
 
-        watch.record("dump_extension_api");
+        watch.record("dump_gdextension_json");
     }
 
     let result = std::fs::read_to_string(json_path)
         .unwrap_or_else(|_| panic!("failed to open file {}", json_path.display()));
+
     watch.record("read_json_file");
     result
 }
 
+pub fn load_gdextension_rust_header(rust_out_path: &Path, watch: &mut StopWatch) -> String {
+    let c_header_path = Path::new(HEADER_PATH);
+    rerun_on_changed(c_header_path);
+
+    let godot_bin = locate_godot_binary();
+    rerun_on_changed(&godot_bin);
+    watch.record("locate_godot");
+
+    // Regenerate API JSON if first time or Godot version is different
+    let version = read_godot_version(&godot_bin);
+    if !c_header_path.exists() || has_version_changed(&version) {
+        dump_header_file(&godot_bin, c_header_path);
+        update_version_file(&version);
+
+        watch.record("dump_gdextension_header");
+    }
+
+    run_bindgen(c_header_path, rust_out_path);
+    watch.record("read_header_file");
+    std::fs::read_to_string(rust_out_path).unwrap_or_else(|_| {
+        panic!(
+            "failed to read generated Rust file {}",
+            rust_out_path.display()
+        )
+    })
+}
+
 fn has_version_changed(current_version: &str) -> bool {
     let version_path = Path::new(GODOT_VERSION_PATH);
 
@@ -92,7 +119,7 @@ fn read_godot_version(godot_bin: &Path) -> String {
 fn dump_extension_api(godot_bin: &Path, out_file: &Path) {
     let cwd = out_file.parent().unwrap();
     std::fs::create_dir_all(cwd).unwrap_or_else(|_| panic!("create directory '{}'", cwd.display()));
-    println!("Dump extension API to dir '{}'...", cwd.display());
+    println!("Dump GDExtension API JSON to dir '{}'...", cwd.display());
 
     Command::new(godot_bin)
         .current_dir(cwd)
@@ -107,6 +134,27 @@ fn dump_extension_api(godot_bin: &Path, out_file: &Path) {
             )
         });
 
+    println!("Generated {}/gdextension_interface.h.", cwd.display());
+}
+
+fn dump_header_file(godot_bin: &Path, out_file: &Path) {
+    let cwd = out_file.parent().unwrap();
+    std::fs::create_dir_all(cwd).unwrap_or_else(|_| panic!("create directory '{}'", cwd.display()));
+    println!("Dump GDExtension header file to dir '{}'...", cwd.display());
+
+    Command::new(godot_bin)
+        .current_dir(cwd)
+        .arg("--headless")
+        .arg("--dump-gdextension-interface")
+        .arg(cwd)
+        .output()
+        .unwrap_or_else(|_| {
+            panic!(
+                "failed to invoke Godot executable '{}'",
+                godot_bin.display()
+            )
+        });
+
     println!("Generated {}/extension_api.json.", cwd.display());
 }