Add a get_gd method to InstanceStorage

Author: lilizoey

godot-core/src/obj/base.rs

@@ -35,6 +35,12 @@ pub struct Base<T: GodotClass> {
 }
 
 impl<T: GodotClass> Base<T> {
+    /// # Safety
+    /// The returned Base is a weak pointer, so holding it will not keep the object alive. It must not be accessed after the object is destroyed.
+    pub(crate) unsafe fn from_base(base: &Base<T>) -> Base<T> {
+        Base::from_obj(Gd::from_obj_sys_weak(base.obj_sys()))
+    }
+
     // Note: not &mut self, to only borrow one field and not the entire struct
     pub(crate) unsafe fn from_sys(base_ptr: sys::GDExtensionObjectPtr) -> Self {
         assert!(!base_ptr.is_null(), "instance base is null pointer");

godot-core/src/registry.rs

@@ -313,9 +313,9 @@ pub mod callbacks {
             unsafe { interface_fn!(classdb_construct_object)(base_class_name.string_sys()) };
 
         let base = unsafe { Base::from_sys(base_ptr) };
-        let user_instance = make_user_instance(base);
+        let user_instance = make_user_instance(unsafe { Base::from_base(&base) });
 
-        let instance = InstanceStorage::<T>::construct(user_instance);
+        let instance = InstanceStorage::<T>::construct(user_instance, base);
         let instance_ptr = instance.into_raw();
         let instance_ptr = instance_ptr as sys::GDExtensionClassInstancePtr;
 

godot-core/src/storage.rs

@@ -29,14 +29,15 @@ mod single_threaded {
     use std::any::type_name;
     use std::cell;
 
-    use crate::obj::GodotClass;
+    use crate::obj::{Base, Gd, GodotClass, Inherits};
     use crate::out;
 
     use super::Lifecycle;
 
     /// Manages storage and lifecycle of user's extension class instances.
     pub struct InstanceStorage<T: GodotClass> {
         user_instance: cell::RefCell<T>,
+        base: Base<T::Base>,
 
         // Declared after `user_instance`, is dropped last
         pub lifecycle: cell::Cell<Lifecycle>,
@@ -45,11 +46,12 @@ mod single_threaded {
 
     /// For all Godot extension classes
     impl<T: GodotClass> InstanceStorage<T> {
-        pub fn construct(user_instance: T) -> Self {
+        pub fn construct(user_instance: T, base: Base<T::Base>) -> Self {
             out!("    Storage::construct             <{}>", type_name::<T>());
 
             Self {
                 user_instance: cell::RefCell::new(user_instance),
+                base,
                 lifecycle: cell::Cell::new(Lifecycle::Alive),
                 godot_ref_count: cell::Cell::new(1),
             }
@@ -101,6 +103,13 @@ mod single_threaded {
             })
         }
 
+        pub fn get_gd(&self) -> Gd<T>
+        where
+            T: Inherits<<T as GodotClass>::Base>,
+        {
+            self.base.clone().cast()
+        }
+
         pub(super) fn godot_ref_count(&self) -> u32 {
             self.godot_ref_count.get()
         }
@@ -113,7 +122,7 @@ mod multi_threaded {
     use std::sync;
     use std::sync::atomic::{AtomicU32, Ordering};
 
-    use crate::obj::GodotClass;
+    use crate::obj::{Base, Gd, GodotClass, Inherits, Share};
     use crate::out;
 
     use super::Lifecycle;
@@ -146,6 +155,7 @@ mod multi_threaded {
     /// Manages storage and lifecycle of user's extension class instances.
     pub struct InstanceStorage<T: GodotClass> {
         user_instance: sync::RwLock<T>,
+        base: Base<T::Base>,
 
         // Declared after `user_instance`, is dropped last
         pub lifecycle: AtomicLifecycle,
@@ -154,11 +164,12 @@ mod multi_threaded {
 
     /// For all Godot extension classes
     impl<T: GodotClass> InstanceStorage<T> {
-        pub fn construct(user_instance: T) -> Self {
+        pub fn construct(user_instance: T, base: Base<T::Base>) -> Self {
             out!("    Storage::construct             <{}>", type_name::<T>());
 
             Self {
                 user_instance: sync::RwLock::new(user_instance),
+                base,
                 lifecycle: AtomicLifecycle::new(Lifecycle::Alive),
                 godot_ref_count: AtomicU32::new(1),
             }
@@ -206,6 +217,13 @@ mod multi_threaded {
             })
         }
 
+        pub fn get_gd(&self) -> Gd<T>
+        where
+            T: Inherits<<T as GodotClass>::Base>,
+        {
+            self.base.clone().cast()
+        }
+
         pub(super) fn godot_ref_count(&self) -> u32 {
             self.godot_ref_count.load(Ordering::Relaxed)
         }