wip2

Author: Bromeon

godot-core/src/obj/base.rs

@@ -84,3 +84,5 @@ impl<T: GodotClass> DerefMut for Base<T> {
         &mut self.obj
     }
 }
+
+

godot-core/src/storage.rs

@@ -12,16 +12,17 @@ use std::any::type_name;
 
 #[derive(Copy, Clone, Debug)]
 pub enum Lifecycle {
+    // Warning: when reordering/changing enumerators, update match in AtomicLifecycle below
     Alive,
     Destroying,
     Dead, // reading this would typically already be too late, only best-effort in case of UB
 }
 
 #[cfg(not(feature = "threads"))]
-pub use single_thread::*;
+pub(crate) use single_thread::*;
 
 #[cfg(feature = "threads")]
-pub use multi_thread::*;
+pub(crate) use multi_thread::*;
 
 #[cfg(not(feature = "threads"))]
 mod single_thread {
@@ -115,21 +116,46 @@ mod single_thread {
 #[cfg(feature = "threads")]
 mod multi_thread {
     use std::any::type_name;
+    use std::sync;
     use std::sync::atomic::{AtomicU32, Ordering};
-    use std::{cell, sync};
 
     use crate::obj::{Base, GodotClass};
-    use crate::{out, sys};
+    use crate::out;
 
     use super::Lifecycle;
 
+    pub struct AtomicLifecycle {
+        atomic: AtomicU32,
+    }
+
+    impl AtomicLifecycle {
+        pub fn new(value: Lifecycle) -> Self {
+            Self {
+                atomic: AtomicU32::new(value as u32),
+            }
+        }
+
+        pub fn get(&self) -> Lifecycle {
+            match self.atomic.load(Ordering::Relaxed) {
+                0 => Lifecycle::Alive,
+                1 => Lifecycle::Dead,
+                2 => Lifecycle::Destroying,
+                other => panic!("Invalid lifecycle {other}"),
+            }
+        }
+
+        pub fn set(&self, value: Lifecycle) {
+            self.atomic.store(value as u32, Ordering::Relaxed);
+        }
+    }
+
     /// Manages storage and lifecycle of user's extension class instances.
     pub struct InstanceStorage<T: GodotClass> {
         user_instance: sync::RwLock<T>,
         cached_base: Base<T::Base>,
 
         // Declared after `user_instance`, is dropped last
-        pub lifecycle: cell::Cell<Lifecycle>,
+        pub lifecycle: AtomicLifecycle,
         godot_ref_count: AtomicU32,
     }
 
@@ -141,12 +167,12 @@ mod multi_thread {
             Self {
                 user_instance: sync::RwLock::new(user_instance),
                 cached_base,
-                lifecycle: cell::Cell::new(Lifecycle::Alive),
+                lifecycle: AtomicLifecycle::new(Lifecycle::Alive),
                 godot_ref_count: AtomicU32::new(1),
             }
         }
 
-        pub(crate) fn on_inc_ref(&mut self) {
+        pub(crate) fn on_inc_ref(&self) {
             self.godot_ref_count.fetch_add(1, Ordering::Relaxed);
             out!(
                 "    Storage::on_inc_ref (rc={})     <{}>", // -- {:?}",
@@ -156,7 +182,7 @@ mod multi_thread {
             );
         }
 
-        pub(crate) fn on_dec_ref(&mut self) {
+        pub(crate) fn on_dec_ref(&self) {
             self.godot_ref_count.fetch_sub(1, Ordering::Relaxed);
             out!(
                 "  | Storage::on_dec_ref (rc={})     <{}>", // -- {:?}",
@@ -195,7 +221,15 @@ mod multi_thread {
         pub(super) fn godot_ref_count(&self) -> u32 {
             self.godot_ref_count.load(Ordering::Relaxed)
         }
+
+        // TODO enable once there is better thread support
+        //fn __static_type_check() {
+        //    enforce_sync::<InstanceStorage<T>>();
+        //}
     }
+
+    // Make sure storage is Sync in multi-threaded case, as it can be concurrently accessed through aliased Gd<T> pointers.
+    //fn enforce_sync<T: Sync>() {}
 }
 
 impl<T: GodotClass> InstanceStorage<T> {
@@ -267,6 +301,9 @@ pub unsafe fn destroy_storage<T: GodotClass>(instance_ptr: sys::GDExtensionClass
     let _drop = Box::from_raw(instance_ptr as *mut InstanceStorage<T>);
 }
 
+// ----------------------------------------------------------------------------------------------------------------------------------------------
+// Callbacks
+
 pub fn nop_instance_callbacks() -> sys::GDExtensionInstanceBindingCallbacks {
     // These could also be null pointers, if they are definitely not invoked (e.g. create_callback only passed to object_get_instance_binding(),
     // when there is already a binding). Current "empty but not null" impl corresponds to godot-cpp (wrapped.hpp).

itest/rust/src/object_test.rs

@@ -763,9 +763,6 @@ pub mod object_test_gd {
     #[derive(GodotClass)]
     #[class(base=Object)]
     pub struct CustomConstructor {
-        #[base]
-        base: Base<Object>,
-
         #[var]
         pub val: i64,
     }
@@ -774,7 +771,7 @@ pub mod object_test_gd {
     impl CustomConstructor {
         #[func]
         pub fn construct_object(val: i64) -> Gd<CustomConstructor> {
-            Gd::with_base(|base| Self { base, val })
+            Gd::with_base(|_base| Self {  val })
         }
     }
 }
@@ -804,10 +801,7 @@ impl DoubleUse {
 
 #[derive(GodotClass)]
 #[class(init, base=Object)]
-struct SignalEmitter {
-    #[base]
-    base: Base<Object>,
-}
+struct SignalEmitter {}
 
 #[godot_api]
 impl SignalEmitter {

itest/rust/src/property_test.rs

@@ -15,28 +15,33 @@ use godot::{
 #[derive(GodotClass)]
 #[class(base=Node)]
 struct HasProperty {
-    #[base]
-    base: Base<Node>,
-
     #[var]
     int_val: i32,
+
     #[var(get = get_int_val_read)]
     int_val_read: i32,
+
     #[var(set = set_int_val_write)]
     int_val_write: i32,
+
     #[var(get = get_int_val_rw, set = set_int_val_rw)]
     int_val_rw: i32,
+
     #[var(get = get_int_val_getter, set)]
     int_val_getter: i32,
+
     #[var(get, set = set_int_val_setter)]
     int_val_setter: i32,
 
     #[var(get = get_string_val, set = set_string_val)]
     string_val: GodotString,
+
     #[var(get = get_object_val, set = set_object_val)]
     object_val: Option<Gd<Object>>,
+
     #[var]
     texture_val: Gd<Texture>,
+
     #[var(get = get_texture_val, set = set_texture_val, hint = PROPERTY_HINT_RESOURCE_TYPE, hint_string = "Texture")]
     texture_val_rw: Option<Gd<Texture>>,
 }
@@ -120,7 +125,7 @@ impl HasProperty {
 
 #[godot_api]
 impl NodeVirtual for HasProperty {
-    fn init(base: Base<Node>) -> Self {
+    fn init(_base: Base<Node>) -> Self {
         HasProperty {
             int_val: 0,
             int_val_read: 2,
@@ -132,7 +137,6 @@ impl NodeVirtual for HasProperty {
             string_val: GodotString::new(),
             texture_val: Texture::new(),
             texture_val_rw: None,
-            base,
         }
     }
 }

itest/rust/src/signal_test.rs

@@ -17,10 +17,7 @@ use crate::itest;
 
 #[derive(GodotClass)]
 #[class(init, base=Object)]
-struct Emitter {
-    #[base]
-    base: Base<Object>,
-}
+struct Emitter {}
 
 #[godot_api]
 impl Emitter {