Merge pull request #567 from lilizoey/feature/get-set-virtual

Add `get` and `set` as virtual methods

Author: Bromeon

godot-codegen/src/class_generator.rs

@@ -1646,6 +1646,28 @@ fn special_virtual_methods(notification_enum_name: &Ident) -> TokenStream {
         fn on_notification(&mut self, what: #notification_enum_name) {
             unimplemented!()
         }
+
+        /// Called whenever [`get()`](crate::engine::Object::get) is called or Godot gets the value of a property.
+        ///
+        /// Should return the given `property`'s value as `Some(value)`, or `None` if the property should be handled normally.
+        ///
+        /// See also in Godot docs:
+        /// * [`Object::_get`](https://docs.godotengine.org/en/stable/classes/class_object.html#class-object-private-method-get).
+        fn get(&self, property: StringName) -> Option<Variant> {
+            unimplemented!()
+        }
+
+        /// Called whenever Godot [`set()`](crate::engine::Object::set) is called or Godot sets the value of a property.
+        ///
+        /// Should set `property` to the given `value` and return `true`, or return `false` to indicate the `property`
+        /// should be handled normally.
+        ///
+        /// See also in Godot docs:
+        /// * [`Object::_set`](https://docs.godotengine.org/en/stable/classes/class_object.html#class-object-private-method-set).
+        fn set(&mut self, property: StringName, value: Variant) -> bool {
+            unimplemented!()
+        }
+
     }
 }
 

godot-core/src/obj/traits.rs

@@ -416,6 +416,7 @@ where
 /// Capability traits, providing dedicated functionalities for Godot classes
 pub mod cap {
     use super::*;
+    use crate::builtin::{StringName, Variant};
     use crate::obj::{Base, Bounds, Gd};
 
     /// Trait for all classes that are default-constructible from the Godot engine.
@@ -483,6 +484,18 @@ pub mod cap {
         fn __godot_register_class(builder: &mut ClassBuilder<Self>);
     }
 
+    #[doc(hidden)]
+    pub trait GodotGet: GodotClass {
+        #[doc(hidden)]
+        fn __godot_get(&self, property: StringName) -> Option<Variant>;
+    }
+
+    #[doc(hidden)]
+    pub trait GodotSet: GodotClass {
+        #[doc(hidden)]
+        fn __godot_set(&mut self, property: StringName, value: Variant) -> bool;
+    }
+
     /// Auto-implemented for `#[godot_api] impl MyClass` blocks
     pub trait ImplementsGodotApi: GodotClass {
         #[doc(hidden)]

godot-core/src/registry.rs

@@ -148,6 +148,22 @@ pub enum PluginComponent {
             ),
         >,
 
+        user_set_fn: Option<
+            unsafe extern "C" fn(
+                p_instance: sys::GDExtensionClassInstancePtr,
+                p_name: sys::GDExtensionConstStringNamePtr,
+                p_value: sys::GDExtensionConstVariantPtr,
+            ) -> sys::GDExtensionBool,
+        >,
+
+        user_get_fn: Option<
+            unsafe extern "C" fn(
+                p_instance: sys::GDExtensionClassInstancePtr,
+                p_name: sys::GDExtensionConstStringNamePtr,
+                r_ret: sys::GDExtensionVariantPtr,
+            ) -> sys::GDExtensionBool,
+        >,
+
         /// Callback for other virtuals.
         get_virtual_fn: unsafe extern "C" fn(
             p_userdata: *mut std::os::raw::c_void,
@@ -373,6 +389,8 @@ fn fill_class_info(component: PluginComponent, c: &mut ClassRegistrationInfo) {
             user_recreate_fn,
             user_to_string_fn,
             user_on_notification_fn,
+            user_set_fn,
+            user_get_fn,
             get_virtual_fn,
         } => {
             c.user_register_fn = user_register_fn;
@@ -390,6 +408,8 @@ fn fill_class_info(component: PluginComponent, c: &mut ClassRegistrationInfo) {
 
             c.godot_params.to_string_func = user_to_string_fn;
             c.godot_params.notification_func = user_on_notification_fn;
+            c.godot_params.set_func = user_set_fn;
+            c.godot_params.get_func = user_get_fn;
             c.user_virtual_fn = Some(get_virtual_fn);
         }
         #[cfg(since_api = "4.1")]
@@ -510,6 +530,7 @@ fn unregister_class_raw(class_name: ClassName) {
 pub mod callbacks {
     use super::*;
     use crate::builder::ClassBuilder;
+    use crate::builtin::Variant;
     use crate::obj::Base;
     use crate::storage::{Storage, StorageRefCounted};
 
@@ -657,6 +678,43 @@ pub mod callbacks {
         T::__godot_notification(&mut *instance, what);
     }
 
+    pub unsafe extern "C" fn get<T: cap::GodotGet>(
+        instance: sys::GDExtensionClassInstancePtr,
+        name: sys::GDExtensionConstStringNamePtr,
+        ret: sys::GDExtensionVariantPtr,
+    ) -> sys::GDExtensionBool {
+        let storage = as_storage::<T>(instance);
+        let instance = storage.get();
+        let property = StringName::from_string_sys(sys::force_mut_ptr(name));
+
+        std::mem::forget(property.clone());
+
+        match T::__godot_get(&*instance, property) {
+            Some(value) => {
+                value.move_var_ptr(ret);
+                true as sys::GDExtensionBool
+            }
+            None => false as sys::GDExtensionBool,
+        }
+    }
+
+    pub unsafe extern "C" fn set<T: cap::GodotSet>(
+        instance: sys::GDExtensionClassInstancePtr,
+        name: sys::GDExtensionConstStringNamePtr,
+        value: sys::GDExtensionConstVariantPtr,
+    ) -> sys::GDExtensionBool {
+        let storage = as_storage::<T>(instance);
+        let mut instance = storage.get_mut();
+
+        let property = StringName::from_string_sys(sys::force_mut_ptr(name));
+        let value = Variant::from_var_sys(sys::force_mut_ptr(value));
+
+        std::mem::forget(property.clone());
+        std::mem::forget(value.clone());
+
+        T::__godot_set(&mut *instance, property, value) as sys::GDExtensionBool
+    }
+
     pub unsafe extern "C" fn reference<T: GodotClass>(instance: sys::GDExtensionClassInstancePtr) {
         let storage = as_storage::<T>(instance);
         storage.on_inc_ref();

godot-macros/src/class/godot_api.rs

@@ -459,12 +459,16 @@ fn transform_trait_impl(original_impl: Impl) -> Result<TokenStream, Error> {
     let mut to_string_impl = TokenStream::new();
     let mut register_class_impl = TokenStream::new();
     let mut on_notification_impl = TokenStream::new();
+    let mut get_impl = TokenStream::new();
+    let mut set_impl = TokenStream::new();
 
     let mut register_fn = None;
     let mut create_fn = None;
     let mut recreate_fn = None;
     let mut to_string_fn = None;
     let mut on_notification_fn = None;
+    let mut get_fn = None;
+    let mut set_fn = None;
 
     let mut virtual_methods = vec![];
     let mut virtual_method_cfg_attrs = vec![];
@@ -591,6 +595,54 @@ fn transform_trait_impl(original_impl: Impl) -> Result<TokenStream, Error> {
                 });
             }
 
+            "get" => {
+                get_impl = quote! {
+                    #get_impl
+
+                    #(#cfg_attrs)*
+                    impl ::godot::obj::cap::GodotGet for #class_name {
+                        fn __godot_get(&self, property: ::godot::builtin::StringName) -> Option<::godot::builtin::Variant> {
+                            use ::godot::obj::UserClass as _;
+                            if ::godot::private::is_class_inactive(Self::__config().is_tool) {
+                                return None;
+                            }
+
+                            <Self as #trait_name>::get(self, property)
+                        }
+                    }
+                };
+
+                get_fn = Some(quote! {
+                    #get_fn
+                    #(#cfg_attrs)*
+                    () => Some(#prv::callbacks::get::<#class_name>),
+                });
+            }
+
+            "set" => {
+                set_impl = quote! {
+                    #set_impl
+
+                    #(#cfg_attrs)*
+                    impl ::godot::obj::cap::GodotSet for #class_name {
+                        fn __godot_set(&mut self, property: ::godot::builtin::StringName, value: ::godot::builtin::Variant) -> bool {
+                            use ::godot::obj::UserClass as _;
+                            if ::godot::private::is_class_inactive(Self::__config().is_tool) {
+                                return false;
+                            }
+
+                            <Self as #trait_name>::set(self, property, value)
+                        }
+                    }
+                };
+
+                set_fn = Some(quote! {
+                    #set_fn
+                    #(#cfg_attrs)*
+                    () => Some(#prv::callbacks::set::<#class_name>),
+                });
+            }
+
             // Other virtual methods, like ready, process etc.
             _ => {
                 let method = util::reduce_to_signature(method);
@@ -659,13 +711,17 @@ fn transform_trait_impl(original_impl: Impl) -> Result<TokenStream, Error> {
     let recreate_fn = convert_to_match_expression_or_none(recreate_fn);
     let to_string_fn = convert_to_match_expression_or_none(to_string_fn);
     let on_notification_fn = convert_to_match_expression_or_none(on_notification_fn);
+    let get_fn = convert_to_match_expression_or_none(get_fn);
+    let set_fn = convert_to_match_expression_or_none(set_fn);
 
     let result = quote! {
         #original_impl
         #godot_init_impl
         #to_string_impl
         #on_notification_impl
         #register_class_impl
+        #get_impl
+        #set_impl
 
         impl ::godot::private::You_forgot_the_attribute__godot_api for #class_name {}
 
@@ -693,6 +749,8 @@ fn transform_trait_impl(original_impl: Impl) -> Result<TokenStream, Error> {
                 user_recreate_fn: #recreate_fn,
                 user_to_string_fn: #to_string_fn,
                 user_on_notification_fn: #on_notification_fn,
+                user_set_fn: #set_fn,
+                user_get_fn: #get_fn,
                 get_virtual_fn: #prv::callbacks::get_virtual::<#class_name>,
             },
             init_level: <#class_name as ::godot::obj::GodotClass>::INIT_LEVEL,

itest/godot/ManualFfiTests.gd

@@ -345,3 +345,26 @@ func test_callable_refcount():
 	var method := Callable(self, "sample_func")
 	assert(method.is_valid())
 	test_obj.free()
+
+func test_get_set():
+	var obj: GetSetTest = GetSetTest.new()
+	assert(not obj.is_get_called())
+	assert(not obj.is_set_called())
+
+	assert_eq(obj.always_get_100, 100)
+	assert(obj.is_get_called())
+	assert(not obj.is_set_called())
+	obj.unset_get_called()
+
+	obj.always_get_100 = 10
+	assert_eq(obj.always_get_100, 100)
+	assert_eq(obj.get_real_always_get_100(), 10)
+	assert(obj.is_set_called())
+	obj.unset_get_called()
+	obj.unset_set_called()
+
+	obj.set_get = 1000
+	assert_eq(obj.set_get, 1000)
+	assert(obj.is_set_called())
+	assert(obj.is_get_called())
+