Update gdext (#36)

Author: TitanNano

Cargo.lock

@@ -10,7 +10,7 @@ version = "0.1.0"
 edition = "2021"
 
 [workspace.dependencies]
-godot = { git = "https://github.com/godot-rust/gdext", rev = "7fd1be904efccd71a9eb980c2e6fffa2d8705ec4" }
+godot = { git = "https://github.com/godot-rust/gdext", rev = "22fd33d4d5213a3fe5db9a58547888cebe35c647" }
 itertools = "0.10.3"
 rand = "0.8.5"
 darling = { version = "0.20.3" }

Cargo.toml

@@ -20,13 +20,13 @@ def lines []: string -> list<string> {
 }
 
 def main []: nothing -> nothing {
-  for file in (ls $"($source_root)/**/*.rs") {
-    let current_header = read_file $file.name | first $license_length
+  for file in (glob $"($source_root)/**/*.rs") {
+    let current_header = read_file $file | first $license_length
 
     if $current_header == $license_notice {
       continue
     }
 
-    read_file $file.name | prepend $license_notice | str join "\n" |  save -f $file.name
+    read_file $file | prepend $license_notice | str join "\n" |  save -f $file.name
   }
 }

license_header.nu

@@ -4,15 +4,12 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
  */
 
-use std::ops::Deref;
-
 use godot::{
     builtin::meta::ToGodot,
     obj::{Gd, GodotClass, Inherits, WithBaseField},
 };
 
 pub trait DowngradeSelf: GodotClass {
-    fn downgrade<F: FnOnce(&Self) -> R, R>(&mut self, closure: F) -> R;
     fn downgrade_gd<F: FnOnce(Gd<Self>) -> R, R>(&mut self, closure: F) -> R;
 }
 
@@ -21,14 +18,6 @@ where
     T: WithBaseField + GodotClass,
     T: Inherits<<T as GodotClass>::Base>,
 {
-    fn downgrade<F: FnOnce(&Self) -> R, R>(&mut self, closure: F) -> R {
-        let mut_base = self.base_mut();
-        let self_gd: Gd<T> = mut_base.to_godot().cast();
-        let slf = self_gd.bind();
-
-        closure(slf.deref())
-    }
-
     fn downgrade_gd<F: FnOnce(Gd<Self>) -> R, R>(&mut self, closure: F) -> R {
         let mut_base = self.base_mut();
         let self_gd = mut_base.to_godot().cast();

rust-script/src/runtime/downgrade_self.rs

@@ -7,11 +7,9 @@
 use std::ops::Deref;
 
 use godot::{
+    builtin::meta::{MethodInfo, PropertyInfo},
     obj::{EngineBitfield, EngineEnum},
-    prelude::{
-        meta::{MethodInfo, PropertyInfo},
-        Array, Dictionary,
-    },
+    prelude::{Array, Dictionary},
     sys::VariantType,
 };
 

rust-script/src/runtime/metadata.rs

@@ -15,11 +15,11 @@ mod rust_script_language;
 use std::{collections::HashMap, sync::RwLock};
 
 use godot::{
-    bind::GodotClass,
     engine::{Engine, RefCounted, ResourceLoader, ResourceSaver, ScriptLanguage},
     log::godot_warn,
     obj::GodotClass,
     prelude::{godot_print, Gd},
+    register::GodotClass,
 };
 use once_cell::sync::Lazy;
 

rust-script/src/runtime/mod.rs

@@ -7,13 +7,16 @@
 use std::{cell::RefCell, collections::HashSet, ffi::c_void};
 
 use godot::{
-    builtin::meta::{MethodInfo, PropertyInfo, ToGodot},
+    builtin::{
+        meta::{MethodInfo, PropertyInfo, ToGodot},
+        Callable,
+    },
     engine::{
-        create_script_instance, notify::ObjectNotification, ClassDb, Engine, IScriptExtension,
-        Script, ScriptExtension, ScriptInstance, ScriptLanguage, WeakRef,
+        create_script_instance, notify::ObjectNotification, object::ConnectFlags, ClassDb, Engine,
+        IScriptExtension, Script, ScriptExtension, ScriptLanguage, WeakRef,
     },
     log::{godot_error, godot_print, godot_warn},
-    obj::{InstanceId, WithBaseField},
+    obj::{EngineEnum, InstanceId, WithBaseField},
     prelude::{
         godot_api, Array, Base, Dictionary, GString, Gd, GodotClass, Object, StringName, Variant,
         VariantArray,
@@ -35,18 +38,17 @@ const NOTIFICATION_EXTENSION_RELOADED: i32 = 2;
 #[derive(GodotClass)]
 #[class(base = ScriptExtension, tool)]
 pub(super) struct RustScript {
-    #[var(get = get_class_name, set = set_class_name, usage_flags = [PROPERTY_USAGE_STORAGE])]
+    #[var(get = get_class_name, set = set_class_name, usage_flags = [STORAGE])]
     class_name: GString,
 
-    #[var(usage_flags = [PROPERTY_USAGE_STORAGE])]
+    #[var(usage_flags = [STORAGE])]
     source_code: GString,
 
-    #[var( get = owner_ids, set = set_owner_ids, usage_flags = [PROPERTY_USAGE_STORAGE])]
+    #[var( get = owner_ids, set = set_owner_ids, usage_flags = [STORAGE])]
     #[allow(dead_code)]
     owner_ids: Array<i64>,
 
     owners: RefCell<Vec<Gd<WeakRef>>>,
-    #[base]
     base: Base<ScriptExtension>,
 }
 
@@ -121,29 +123,28 @@ impl RustScript {
             .collect();
     }
 
-    fn init_script_instance(instance: &mut RustScriptInstance) {
-        match instance.call(StringName::from("_init"), &[]) {
-            Ok(_) => (),
-            Err(err) => {
-                use godot::sys::*;
-
-                if !matches!(
-                    err,
-                    GDEXTENSION_CALL_OK | GDEXTENSION_CALL_ERROR_INVALID_METHOD
-                ) {
-                    let error_code = match err {
-                        GDEXTENSION_CALL_ERROR_INSTANCE_IS_NULL => "INSTANCE_IS_NULL",
-                        GDEXTENSION_CALL_ERROR_INVALID_ARGUMENT => "INVALID_ARGUMENT",
-                        GDEXTENSION_CALL_ERROR_METHOD_NOT_CONST => "METHOD_NOT_CONST",
-                        GDEXTENSION_CALL_ERROR_TOO_FEW_ARGUMENTS => "TOO_FEW_ARGUMENTS",
-                        GDEXTENSION_CALL_ERROR_TOO_MANY_ARGUMENTS => "TOO_MANY_ARGUMENTS",
-                        _ => "UNKNOWN",
-                    };
-
-                    godot_error!("failed to call rust script _init fn: {}", error_code);
-                }
-            }
+    #[func]
+    fn init_script_instance(base: Variant) {
+        let mut base: Gd<Object> = match base.try_to() {
+            Ok(base) => base,
+            Err(err) => panic!(
+                "init_rust_script_instance was called without base object bind!\n{}",
+                err
+            ),
         };
+
+        if let Err(err) = base.get_script().try_to::<Gd<RustScript>>() {
+            godot_warn!("expected new script to be previously assigned RustScript, but it wasn't!");
+            godot_warn!("{}", err);
+
+            return;
+        }
+
+        if !base.has_method("_init".into()) {
+            return;
+        }
+
+        base.call(StringName::from("_init"), &[]);
     }
 }
 
@@ -194,16 +195,26 @@ impl IScriptExtension for RustScript {
         false
     }
 
-    unsafe fn instance_create(&self, for_object: Gd<Object>) -> *mut c_void {
+    unsafe fn instance_create(&self, mut for_object: Gd<Object>) -> *mut c_void {
         self.owners
             .borrow_mut()
             .push(godot::engine::utilities::weakref(for_object.to_variant()).to());
 
         let data = self.create_remote_instance(for_object.clone());
-        let mut instance = RustScriptInstance::new(data, for_object, self.to_gd());
+        let instance = RustScriptInstance::new(data, for_object.clone(), self.to_gd());
+
+        let callbale_args = VariantArray::from(&[for_object.to_variant()]);
+
+        for_object
+            .connect_ex(
+                StringName::from("script_changed"),
+                Callable::from_object_method(&self.to_gd(), "init_script_instance")
+                    .bindv(callbale_args),
+            )
+            .flags(ConnectFlags::ONE_SHOT.ord() as u32)
+            .done();
 
-        Self::init_script_instance(&mut instance);
-        create_script_instance(instance)
+        create_script_instance(instance, for_object)
     }
 
     unsafe fn placeholder_instance_create(&self, for_object: Gd<Object>) -> *mut c_void {
@@ -213,7 +224,7 @@ impl IScriptExtension for RustScript {
 
         let placeholder = RustScriptPlaceholder::new(self.to_gd());
 
-        create_script_instance(placeholder)
+        create_script_instance(placeholder, for_object)
     }
 
     fn is_valid(&self) -> bool {