Add Callable::from_custom()

Author: Bromeon

godot-core/src/builtin/array.rs

@@ -178,6 +178,8 @@ impl<T: VariantMetadata> Array<T> {
             interface_fn!(array_operator_index_const)(self.sys(), index)
         };
 
+        // Signature is wrong in GDExtension, semantically this is a const ptr
+        let variant_ptr = sys::to_const_ptr(variant_ptr);
         Variant::ptr_from_sys(variant_ptr)
     }
 

godot-core/src/builtin/callable.rs

@@ -6,15 +6,13 @@
 
 use godot_ffi as sys;
 
-use crate::builtin::{inner, ToVariant, Variant};
+use crate::builtin::{inner, StringName, ToVariant, Variant, VariantArray};
 use crate::engine::Object;
 use crate::obj::mem::Memory;
 use crate::obj::{Gd, GodotClass, InstanceId};
-use std::fmt;
+use std::{fmt, ptr};
 use sys::{ffi_methods, GodotFfi};
 
-use super::{StringName, VariantArray};
-
 /// A `Callable` represents a function in Godot.
 ///
 /// Usually a callable is a reference to an `Object` and a method name, this is a standard callable. But can
@@ -53,14 +51,47 @@ impl Callable {
         }
     }
 
+    /// Create a callable representing a Rust function.
+    // #[cfg(since_api = "4.2")]
+    pub fn from_custom<C: RustCallable>(callable: C) -> Self {
+        // Double box could be avoided if we propagate C through all functions.
+        let wrapper = CallableUserdata {
+            callable: Box::new(callable),
+        };
+        Self::from_custom_inner(Box::new(wrapper))
+    }
+
+    // #[cfg(since_api = "4.2")]
+    fn from_custom_inner(callable: Box<CallableUserdata>) -> Self {
+        let mut info = sys::GDExtensionCallableCustomInfo {
+            callable_userdata: Box::into_raw(callable) as *mut std::ffi::c_void,
+            token: ptr::null_mut(),
+            object: ptr::null_mut(),
+            call_func: Some(rust_callable_call),
+            is_valid_func: None,
+            free_func: Some(rust_callable_destroy),
+            hash_func: Some(rust_callable_hash),
+            equal_func: Some(rust_callable_equal),
+            // < is only used in niche scenarios and default is usually good enough, see https://github.com/godotengine/godot/issues/81901.
+            less_than_func: None,
+            to_string_func: Some(rust_callable_to_string),
+        };
+
+        unsafe {
+            Callable::from_sys_init(|type_ptr| {
+                sys::interface_fn!(callable_custom_create)(type_ptr, ptr::addr_of_mut!(info))
+            })
+        }
+    }
+
     /// Creates an invalid/empty object that is not able to be called.
     ///
     /// _Godot equivalent: `Callable()`_
     pub fn invalid() -> Self {
         unsafe {
             Self::from_sys_init(|self_ptr| {
-                let ctor = ::godot_ffi::builtin_fn!(callable_construct_default);
-                ctor(self_ptr, std::ptr::null_mut())
+                let ctor = sys::builtin_fn!(callable_construct_default);
+                ctor(self_ptr, ptr::null_mut())
             })
         }
     }
@@ -177,13 +208,10 @@ impl_builtin_traits! {
         // Currently no Default::default() to encourage explicit valid initialization.
         //Default => callable_construct_default;
 
-        // Equality for custom callables depend on the equality implementation of that custom callable. This
-        // is from what i can tell currently implemented as total equality in all cases, but i dont believe
-        // there are any guarantees that all implementations of equality for custom callables will be.
-        //
-        // So we cannot implement `Eq` here and be confident equality will be total for all future custom
-        // callables.
+        // Equality for custom callables depend on the equality implementation of that custom callable.
+        // So we cannot implement `Eq` here and be confident equality will be total for all future custom callables.
         PartialEq => callable_operator_equal;
+        // PartialOrd => callable_operator_less;
         Clone => callable_construct_copy;
         Drop => callable_destroy;
     }
@@ -202,7 +230,7 @@ unsafe impl GodotFfi for Callable {
     }
 }
 
-impl std::fmt::Debug for Callable {
+impl fmt::Debug for Callable {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         let method = self.method_name();
         let object = self.object();
@@ -214,8 +242,104 @@ impl std::fmt::Debug for Callable {
     }
 }
 
-impl std::fmt::Display for Callable {
+impl fmt::Display for Callable {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         write!(f, "{}", self.to_variant())
     }
 }
+
+// ----------------------------------------------------------------------------------------------------------------------------------------------
+// Callbacks for custom implementations
+
+// #[cfg(since_api = "4.2")]
+use custom_callable::*;
+
+// #[cfg(since_api = "4.2")]
+pub use custom_callable::RustCallable;
+
+// #[cfg(since_api = "4.2")]
+mod custom_callable {
+    use super::*;
+    use crate::builtin::GodotString;
+    use std::hash::Hash;
+
+    pub struct CallableUserdata {
+        pub callable: Box<dyn RustCallable>,
+    }
+
+    impl CallableUserdata {
+        unsafe fn inner_from_raw<'a>(void_ptr: *mut std::ffi::c_void) -> &'a dyn RustCallable {
+            let ptr = void_ptr as *mut CallableUserdata;
+            &(*ptr).callable
+        }
+    }
+
+    pub trait RustCallable:
+        'static + Sized + PartialEq + Hash + fmt::Display + Send + Sync
+    where
+        Self: Sized,
+    {
+        fn invoke(&mut self, args: &[&Variant]) -> Result<Variant, ()>;
+    }
+
+    pub unsafe extern "C" fn rust_callable_call(
+        callable_userdata: *mut std::ffi::c_void,
+        p_args: *const sys::GDExtensionConstVariantPtr,
+        p_argument_count: sys::GDExtensionInt,
+        r_return: sys::GDExtensionVariantPtr,
+        r_error: *mut sys::GDExtensionCallError,
+    ) {
+        let arg_refs: &[&Variant] =
+            Variant::unbounded_refs_from_sys(p_args, p_argument_count as usize);
+
+        let mut c = CallableUserdata::inner_from_raw(callable_userdata);
+
+        let result = c.invoke(arg_refs);
+        crate::builtin::meta::varcall_return_checked(result, r_return, r_error);
+    }
+
+    pub unsafe extern "C" fn rust_callable_destroy(callable_userdata: *mut std::ffi::c_void) {
+        let rust_ptr = callable_userdata as *mut CallableUserdata;
+        let _drop = Box::from_raw(rust_ptr);
+    }
+
+    pub unsafe extern "C" fn rust_callable_hash(callable_userdata: *mut std::ffi::c_void) -> u32 {
+        let c = CallableUserdata::inner_from_raw(callable_userdata);
+
+        // Just cut off top bits, not best-possible hash.
+        sys::hash_value(c) as u32
+    }
+
+    pub unsafe extern "C" fn rust_callable_equal(
+        callable_userdata_a: *mut std::ffi::c_void,
+        callable_userdata_b: *mut std::ffi::c_void,
+    ) -> sys::GDExtensionBool {
+        let a = CallableUserdata::inner_from_raw(callable_userdata_a);
+        let b = CallableUserdata::inner_from_raw(callable_userdata_b);
+
+        (a == b) as sys::GDExtensionBool
+    }
+
+    pub unsafe extern "C" fn rust_callable_less(
+        callable_userdata_a: *mut std::ffi::c_void,
+        callable_userdata_b: *mut std::ffi::c_void,
+    ) -> sys::GDExtensionBool {
+        let a = CallableUserdata::inner_from_raw(callable_userdata_a);
+        let b = CallableUserdata::inner_from_raw(callable_userdata_b);
+
+        (a < b) as sys::GDExtensionBool
+    }
+
+    pub unsafe extern "C" fn rust_callable_to_string(
+        callable_userdata: *mut std::ffi::c_void,
+        r_is_valid: *mut sys::GDExtensionBool,
+        r_out: sys::GDExtensionStringPtr,
+    ) {
+        let c = CallableUserdata::inner_from_raw(callable_userdata);
+        let s = StringName::from(c.to_string());
+
+        s.move_string_ptr(r_out);
+
+        *r_is_valid = true as sys::GDExtensionBool;
+    }
+}

godot-core/src/builtin/meta/signature.rs

@@ -389,6 +389,23 @@ unsafe fn varcall_return<R: ToVariant>(
     (*err).error = sys::GDEXTENSION_CALL_OK;
 }
 
+/// Moves `ret_val` into `ret`, if it is `Ok(...)`. Otherwise sets an error.
+///
+/// # Safety
+/// See [`varcall_return`].
+pub(crate) unsafe fn varcall_return_checked<R: ToVariant>(
+    ret_val: Result<R, ()>, // TODO Err should be custom CallError enum
+    ret: sys::GDExtensionVariantPtr,
+    err: *mut sys::GDExtensionCallError,
+) {
+    if let Ok(ret_val) = ret_val {
+        varcall_return(ret_val, ret, err);
+    } else {
+        *err = sys::default_call_error();
+        (*err).error = sys::GDEXTENSION_CALL_ERROR_INVALID_ARGUMENT;
+    }
+}
+
 /// Convert the `N`th argument of `args_ptr` into a value of type `P`.
 ///
 /// # Safety

godot-core/src/builtin/variant/mod.rs

@@ -229,10 +229,24 @@ impl Variant {
     }
 
     /// Converts to variant pointer; can be a null pointer.
-    pub(crate) fn ptr_from_sys(variant_ptr: sys::GDExtensionVariantPtr) -> *const Variant {
+    pub(crate) fn ptr_from_sys(variant_ptr: sys::GDExtensionConstVariantPtr) -> *const Variant {
         variant_ptr as *const Variant
     }
 
+    /// # Safety
+    ///
+    pub(crate) unsafe fn unbounded_refs_from_sys<'a>(
+        variant_ptr_array: *const sys::GDExtensionConstVariantPtr,
+        length: usize,
+    ) -> &'a [&'a Variant] {
+        let variant_ptr_array: &'a [sys::GDExtensionConstVariantPtr] =
+            std::slice::from_raw_parts(variant_ptr_array, length);
+
+        // SAFETY: raw pointers and references have the same memory layout.
+        // See https://doc.rust-lang.org/reference/type-layout.html#pointers-and-references-layout.
+        unsafe { std::mem::transmute(variant_ptr_array) }
+    }
+
     /// Converts to variant mut pointer; can be a null pointer.
     pub(crate) fn ptr_from_sys_mut(variant_ptr: sys::GDExtensionVariantPtr) -> *mut Variant {
         variant_ptr as *mut Variant

godot-core/src/registry.rs

@@ -397,6 +397,7 @@ pub mod callbacks {
         storage.on_dec_ref();
     }
 
+    // ----------------------------------------------------------------------------------------------------------------------------------------------
     // Safe, higher-level methods
 
     /// Abstracts the `GodotInit` away, for contexts where this trait bound is not statically available
@@ -434,7 +435,9 @@ pub mod callbacks {
     }
 }
 
-// Substitute for Default impl
+// ----------------------------------------------------------------------------------------------------------------------------------------------
+// Substitutes for Default impl
+
 // Yes, bindgen can implement Default, but only for _all_ types (with single exceptions).
 // For FFI types, it's better to have explicit initialization in the general case though.
 fn default_registration_info(class_name: ClassName) -> ClassRegistrationInfo {

itest/rust/src/builtin_tests/containers/callable_test.rs

@@ -6,7 +6,9 @@
 
 use godot::bind::{godot_api, GodotClass};
 use godot::builtin::inner::InnerCallable;
-use godot::builtin::{varray, Callable, GodotString, StringName, ToVariant, Variant};
+use godot::builtin::{
+    varray, Callable, GodotString, StringName, ToVariant, Variant, VariantOperator,
+};
 use godot::engine::{Node2D, Object};
 use godot::obj::Gd;
 
@@ -125,3 +127,65 @@ fn callable_call_engine() {
 
     obj.free();
 }
+
+// #[cfg(since_api = "4.2")]
+mod custom_callable {
+    use super::*;
+    use godot::builtin::Dictionary;
+
+    #[itest]
+    fn callable_custom_invoke() {
+        let my_rust_callable = Adder { sum: 0 };
+        let callable = Callable::from_custom(my_rust_callable);
+
+        assert!(callable.is_valid());
+        assert!(!callable.is_null());
+        assert!(callable.is_custom());
+        assert!(callable.object().is_none());
+
+        let sum1 = callable.callv(varray![3, 9, 2, 1]);
+        assert_eq!(sum1, 15.to_variant());
+
+        let sum2 = callable.callv(varray![4]);
+        assert_eq!(sum2, 19.to_variant());
+    }
+
+    #[itest]
+    fn callable_custom_to_string() {
+        let my_rust_callable = Adder { sum: 0 };
+        let callable = Callable::from_custom(my_rust_callable);
+
+        println!("to_string: {}", callable);
+        println!("equal: {}", callable == callable);
+        println!("equal2: {}", callable.to_variant() == callable.to_variant());
+        println!("hash: {}", callable.hash());
+    }
+
+    #[itest]
+    fn callable_custom_equal() {
+        let a = Callable::from_custom(Adder { sum: 0 });
+        let b = Callable::from_custom(Adder { sum: 0 });
+        println!("equal: {}", a == b);
+        println!("equal2: {}", a.to_variant() == b.to_variant());
+
+        let mut dict = Dictionary::new();
+
+        dict.insert(a, "hello");
+        dict.insert(b, "hi");
+    }
+
+
+    struct Adder {
+        sum: i32,
+    }
+
+    impl godot::builtin::RustCallable for Adder {
+        fn invoke(&mut self, args: &[&Variant]) -> Result<Variant, ()> {
+            for arg in args {
+                self.sum += arg.to::<i32>();
+            }
+
+            Ok(self.sum.to_variant())
+        }
+    }
+}