Support for lifecycle notifications

Author: Bromeon

godot-codegen/src/central_generator.rs

@@ -136,6 +136,8 @@ fn make_sys_code(central_items: &CentralItems) -> String {
             #(#opaque_types)*
         }
 
+        // ----------------------------------------------------------------------------------------------------------------------------------------------
+
         pub struct GlobalMethodTable {
             #(#variant_fn_decls)*
         }
@@ -148,6 +150,8 @@ fn make_sys_code(central_items: &CentralItems) -> String {
             }
         }
 
+        // ----------------------------------------------------------------------------------------------------------------------------------------------
+
         #[derive(Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash, Debug)]
         #[repr(i32)]
         pub enum VariantType {
@@ -180,6 +184,8 @@ fn make_sys_code(central_items: &CentralItems) -> String {
             ffi_methods! { type GDExtensionTypePtr = *mut Self; .. }
         }
 
+        // ----------------------------------------------------------------------------------------------------------------------------------------------
+
         #[derive(Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash, Debug)]
         #[repr(i32)]
         pub enum VariantOperator {
@@ -262,7 +268,7 @@ fn make_core_code(central_items: &CentralItems) -> String {
 }
 
 fn make_central_items(api: &ExtensionApi, build_config: &str, ctx: &mut Context) -> CentralItems {
-    let mut opaque_types = vec![];
+    let mut opaque_types = Vec::new();
     for class in &api.builtin_class_sizes {
         if class.build_configuration == build_config {
             for ClassSize { name, size } in &class.sizes {
@@ -327,7 +333,7 @@ fn make_central_items(api: &ExtensionApi, build_config: &str, ctx: &mut Context)
 
         result
             .variant_op_enumerators_pascal
-            .push(ident(&shout_to_pascal(name)));
+            .push(ident(&util::shout_to_pascal(name)));
         result
             .variant_op_enumerators_ord
             .push(Literal::i32_unsuffixed(op.value));
@@ -703,22 +709,3 @@ fn is_trivial(type_names: &TypeNames) -> bool {
 
     list.contains(&type_names.json_builtin_name.as_str())
 }
-
-fn shout_to_pascal(shout_case: &str) -> String {
-    let mut result = String::with_capacity(shout_case.len());
-    let mut next_upper = true;
-
-    for ch in shout_case.chars() {
-        if next_upper {
-            assert_ne!(ch, '_'); // no double underscore
-            result.push(ch); // unchanged
-            next_upper = false;
-        } else if ch == '_' {
-            next_upper = true;
-        } else {
-            result.push(ch.to_ascii_lowercase());
-        }
-    }
-
-    result
-}

godot-codegen/src/class_generator.rs

@@ -1011,12 +1011,37 @@ fn special_virtual_methods() -> TokenStream {
         fn register_class(builder: &mut crate::builder::ClassBuilder<Self>) {
             unimplemented!()
         }
+
+        /// Godot constructor, accepting an injected `base` object.
+        ///
+        /// `base` refers to the base instance of the class, which can either be stored in a `#[base]` field or discarded.
+        /// This method returns a fully-constructed instance, which will then be moved into a `Gd<T>` pointer.
         fn init(base: crate::obj::Base<Self::Base>) -> Self {
             unimplemented!()
         }
+
+        /// String representation of the Godot instance.
+        ///
+        /// Override this method to define how the instance is represented as a string.
+        /// Used by `str()` and `print()` in GDScript, among others.
         fn to_string(&self) -> crate::builtin::GodotString {
             unimplemented!()
         }
+
+        /// Called when the object receives a Godot notification.
+        ///
+        /// The type of notification can be identified through `what`, by comparing it with a `NOTIFICATION_*` constant. These constants are
+        /// defined across multiple classes, most notably in [`Node`](https://docs.godotengine.org/en/stable/classes/class_node.html#constants).
+        ///
+        /// This method is named `_notification` in Godot, but `on_notification` in Rust, to avoid conflicts with the
+        /// [`Object::notification`][crate::engine::Object::notification] method that _issues_ notifications.
+        ///
+        /// See also in Godot docs:
+        /// * [`Object::_notification`](https://docs.godotengine.org/en/stable/classes/class_object.html#class-object-method-notification).
+        /// * [Godot notifications](https://docs.godotengine.org/en/stable/tutorials/best_practices/godot_notifications.html).
+        fn on_notification(&mut self, what: i32) {
+            unimplemented!()
+        }
     }
 }
 

godot-core/src/obj/traits.rs

@@ -156,6 +156,13 @@ pub mod cap {
         fn __godot_to_string(&self) -> GodotString;
     }
 
+    // TODO Evaluate whether we want this public or not
+    #[doc(hidden)]
+    pub trait GodotNotification: GodotClass {
+        #[doc(hidden)]
+        fn __godot_notification(&mut self, what: i32);
+    }
+
     // TODO Evaluate whether we want this public or not
     #[doc(hidden)]
     pub trait GodotRegisterClass: GodotClass {
@@ -174,7 +181,7 @@ pub mod cap {
         fn __register_exports();
     }
 
-    /// Auto-implemented for `#[godot_api] impl ***Virtual for MyClass` blocks
+    /// Auto-implemented for `#[godot_api] impl XyVirtual for MyClass` blocks
     pub trait ImplementsGodotVirtual: GodotClass {
         #[doc(hidden)]
         fn __virtual_call(_name: &str) -> sys::GDExtensionClassCallVirtual;

godot-core/src/registry.rs

@@ -88,7 +88,15 @@ pub enum PluginComponent {
             unsafe extern "C" fn(
                 p_instance: sys::GDExtensionClassInstancePtr,
                 r_is_valid: *mut sys::GDExtensionBool,
-                p_out: sys::GDExtensionStringPtr,
+                r_out: sys::GDExtensionStringPtr,
+            ),
+        >,
+
+        /// User-defined `on_notification` function
+        user_on_notification_fn: Option<
+            unsafe extern "C" fn(
+                p_instance: sys::GDExtensionClassInstancePtr, //
+                p_what: i32,
             ),
         >,
 
@@ -113,7 +121,11 @@ struct ClassRegistrationInfo {
 
 /// Registers a class with static type information.
 pub fn register_class<
-    T: cap::GodotInit + cap::ImplementsGodotVirtual + cap::GodotToString + cap::GodotRegisterClass,
+    T: cap::GodotInit
+        + cap::ImplementsGodotVirtual
+        + cap::GodotToString
+        + cap::GodotNotification
+        + cap::GodotRegisterClass,
 >() {
     // TODO: provide overloads with only some trait impls
 
@@ -122,6 +134,7 @@ pub fn register_class<
 
     let godot_params = sys::GDExtensionClassCreationInfo {
         to_string_func: Some(callbacks::to_string::<T>),
+        notification_func: Some(callbacks::on_notification::<T>),
         reference_func: Some(callbacks::reference::<T>),
         unreference_func: Some(callbacks::unreference::<T>),
         create_instance_func: Some(callbacks::create::<T>),
@@ -203,11 +216,13 @@ fn fill_class_info(component: PluginComponent, c: &mut ClassRegistrationInfo) {
             user_register_fn,
             user_create_fn,
             user_to_string_fn,
+            user_on_notification_fn,
             get_virtual_fn,
         } => {
             c.user_register_fn = user_register_fn;
             fill_into(&mut c.godot_params.create_instance_func, user_create_fn);
             c.godot_params.to_string_func = user_to_string_fn;
+            c.godot_params.notification_func = user_on_notification_fn;
             c.godot_params.get_virtual_func = Some(get_virtual_fn);
         }
     }
@@ -348,13 +363,23 @@ pub mod callbacks {
 
         let storage = as_storage::<T>(instance);
         let instance = storage.get();
-        let string = <T as cap::GodotToString>::__godot_to_string(&*instance);
+        let string = T::__godot_to_string(&*instance);
 
         // Transfer ownership to Godot, disable destructor
         string.write_string_sys(out_string);
         std::mem::forget(string);
     }
 
+    pub unsafe extern "C" fn on_notification<T: cap::GodotNotification>(
+        instance: sys::GDExtensionClassInstancePtr,
+        what: i32,
+    ) {
+        let storage = as_storage::<T>(instance);
+        let mut instance = storage.get_mut();
+
+        T::__godot_notification(&mut *instance, what);
+    }
+
     pub unsafe extern "C" fn reference<T: GodotClass>(instance: sys::GDExtensionClassInstancePtr) {
         let storage = as_storage::<T>(instance);
         storage.on_inc_ref();

godot-macros/src/godot_api.rs

@@ -218,10 +218,12 @@ fn transform_trait_impl(original_impl: Impl) -> Result<TokenStream, Error> {
     let mut godot_init_impl = TokenStream::new();
     let mut to_string_impl = TokenStream::new();
     let mut register_class_impl = TokenStream::new();
+    let mut on_notification_impl = TokenStream::new();
 
     let mut register_fn = quote! { None };
     let mut create_fn = quote! { None };
     let mut to_string_fn = quote! { None };
+    let mut on_notification_fn = quote! { None };
 
     let mut virtual_methods = vec![];
     let mut virtual_method_names = vec![];
@@ -274,6 +276,20 @@ fn transform_trait_impl(original_impl: Impl) -> Result<TokenStream, Error> {
                 to_string_fn = quote! { Some(#prv::callbacks::to_string::<#class_name>) };
             }
 
+            "on_notification" => {
+                on_notification_impl = quote! {
+                    impl ::godot::obj::cap::GodotNotification for #class_name {
+                        fn __godot_notification(&mut self, what: i32) {
+                            <Self as #trait_name>::on_notification(self, what)
+                        }
+                    }
+                };
+
+                on_notification_fn = quote! {
+                    Some(#prv::callbacks::on_notification::<#class_name>)
+                };
+            }
+
             // Other virtual methods, like ready, process etc.
             _ => {
                 let method = util::reduce_to_signature(method);
@@ -300,6 +316,7 @@ fn transform_trait_impl(original_impl: Impl) -> Result<TokenStream, Error> {
         #original_impl
         #godot_init_impl
         #to_string_impl
+        #on_notification_impl
         #register_class_impl
 
         impl ::godot::private::You_forgot_the_attribute__godot_api for #class_name {}
@@ -323,6 +340,7 @@ fn transform_trait_impl(original_impl: Impl) -> Result<TokenStream, Error> {
                 user_register_fn: #register_fn,
                 user_create_fn: #create_fn,
                 user_to_string_fn: #to_string_fn,
+                user_on_notification_fn: #on_notification_fn,
                 get_virtual_fn: #prv::callbacks::get_virtual::<#class_name>,
             },
         });

itest/rust/src/virtual_methods_test.rs

@@ -23,6 +23,8 @@ struct WithoutInit {
     some_base: Base<RefCounted>,
 }
 
+// ----------------------------------------------------------------------------------------------------------------------------------------------
+
 #[derive(GodotClass, Debug)]
 #[class(init, base=RefCounted)]
 struct VirtualMethodTest {
@@ -42,6 +44,8 @@ impl RefCountedVirtual for VirtualMethodTest {
     }
 }
 
+// ----------------------------------------------------------------------------------------------------------------------------------------------
+
 #[derive(GodotClass, Debug)]
 #[class(base=Node2D)]
 struct ReadyVirtualTest {
@@ -64,6 +68,8 @@ impl Node2DVirtual for ReadyVirtualTest {
     }
 }
 
+// ----------------------------------------------------------------------------------------------------------------------------------------------
+
 #[derive(GodotClass, Debug)]
 #[class(base=Node2D)]
 struct TreeVirtualTest {
@@ -92,6 +98,8 @@ impl Node2DVirtual for TreeVirtualTest {
     }
 }
 
+// ----------------------------------------------------------------------------------------------------------------------------------------------
+
 #[derive(GodotClass, Debug)]
 #[class(base=Node)]
 struct ReturnVirtualTest {
@@ -114,6 +122,26 @@ impl NodeVirtual for ReturnVirtualTest {
 
 // ----------------------------------------------------------------------------------------------------------------------------------------------
 
+#[derive(GodotClass, Debug)]
+#[class(base=Node, init)]
+struct NotificationTest {
+    #[base]
+    base: Base<Node>,
+
+    sequence: Vec<i32>,
+}
+
+#[godot_api]
+impl NodeVirtual for NotificationTest {
+    fn on_notification(&mut self, what: i32) {
+        self.sequence.push(what);
+    }
+
+    fn ready(&mut self) {}
+}
+
+// ----------------------------------------------------------------------------------------------------------------------------------------------
+
 #[itest]
 fn test_to_string() {
     let _obj = Gd::<VirtualMethodTest>::new_default();
@@ -238,10 +266,33 @@ fn test_tree_enters_exits(test_context: &TestContext) {
 }
 
 #[itest]
-fn test_virtual_method_with_return(_test_context: &TestContext) {
+fn test_virtual_method_with_return() {
     let obj = Gd::<ReturnVirtualTest>::new_default();
     let output = obj.bind().get_configuration_warnings();
+
     assert!(output.contains("Hello".into()));
     assert_eq!(output.len(), 1);
+
+    obj.free();
+}
+
+#[itest]
+fn test_notifications() {
+    let obj = Gd::<NotificationTest>::new_default();
+
+    let mut node = obj.share().upcast::<Node>();
+    node.notification(Node::NOTIFICATION_UNPAUSED as i64, false);
+    node.notification(Node::NOTIFICATION_EDITOR_POST_SAVE as i64, false);
+    node.notification(Node::NOTIFICATION_WM_SIZE_CHANGED as i64, true);
+
+    assert_eq!(
+        obj.bind().sequence,
+        vec![
+            Node::NOTIFICATION_UNPAUSED,
+            Node::NOTIFICATION_EDITOR_POST_SAVE,
+            Node::NOTIFICATION_WM_SIZE_CHANGED,
+        ]
+    );
+
     obj.free();
 }