Support OnEditor in scripts (#79)

Support for the `OnEditor` wrapper type to be used in script properties.

Author: TitanNano

derive/src/enums.rs

@@ -136,6 +136,16 @@ pub fn script_enum_derive(input: proc_macro::TokenStream) -> proc_macro::TokenSt
             }
         }
 
+        impl #godot_types::prelude::Var for #enum_ident {
+            fn get_property(&self) -> Self::Via {
+                self.into()
+            }
+
+            fn set_property(&mut self, value: Self::Via) {
+                *self = #godot_types::meta::FromGodot::try_from_godot(value).unwrap();
+            }
+        }
+
         #derive_export
     };
 

derive/src/impl_attribute.rs

@@ -60,13 +60,13 @@ pub fn godot_script_impl(
                     let arg_rust_type = arg.ty.as_ref();
                     let arg_type = rust_to_variant_type(arg.ty.as_ref()).unwrap();
 
-                    if is_context_type(arg.ty.as_ref()) { 
+                    if is_context_type(arg.ty.as_ref()) {
                         (
                             quote!(),
 
                             quote_spanned!(arg.span() => ctx,)
                         )
-                    } else { 
+                    } else {
                         (
                             quote_spanned! {
                                 arg.span() =>

derive/src/lib.rs

@@ -279,7 +279,7 @@ fn derive_get_field_dispatch(field: &SpannedValue<FieldOpts>) -> TokenStream {
 
     quote_spanned! {field.ty.span()=>
         #[allow(clippy::needless_borrow)]
-        #field_name => Some(#godot_types::prelude::ToGodot::to_variant(&#accessor)),
+        #field_name => Some(#godot_types::prelude::ToGodot::to_variant(&::godot_rust_script::GetScriptProperty::get_property(&#accessor))),
     }
 }
 
@@ -313,7 +313,9 @@ fn derive_set_field_dispatch(field: &SpannedValue<FieldOpts>) -> TokenStream {
 
     let assignment = match opts.set {
         Some(setter) => quote_spanned!(setter.span()=> #setter(self, local_value)),
-        None => quote_spanned!(field.ty.span() => self.#field_ident = local_value),
+        None => {
+            quote_spanned!(field.ty.span() => ::godot_rust_script::SetScriptProperty::set_property(&mut self.#field_ident, local_value))
+        }
     };
 
     quote! {

rust-script/build.rs

@@ -6,4 +6,4 @@
 
 fn main() {
     godot_bindings::emit_godot_version_cfg();
-}
+}

rust-script/src/interface.rs

@@ -5,6 +5,7 @@
  */
 
 mod export;
+mod on_editor;
 mod signals;
 
 use std::marker::PhantomData;
@@ -18,6 +19,7 @@ use godot::prelude::{ConvertError, Gd, Object, StringName, Variant};
 pub use crate::runtime::Context;
 
 pub use export::GodotScriptExport;
+pub use on_editor::OnEditor;
 #[expect(deprecated)]
 pub use signals::{ScriptSignal, Signal};
 
@@ -135,6 +137,20 @@ impl<T: GodotScript> ToGodot for RsRef<T> {
     }
 }
 
+impl<'v, T: GodotScript> ::godot::prelude::Var for RsRef<T>
+where
+    Self: GodotConvert<Via = <Self as ToGodot>::ToVia<'v>>,
+    Self: 'v,
+{
+    fn get_property(&self) -> Self::Via {
+        <Self as ToGodot>::to_godot(self)
+    }
+
+    fn set_property(&mut self, value: Self::Via) {
+        <Self as FromGodot>::from_godot(value);
+    }
+}
+
 #[derive(thiserror::Error, Debug)]
 pub enum GodotScriptCastError {
     #[error("Object has no script attached!")]
@@ -196,6 +212,59 @@ impl<T: GodotScript, B: Inherits<T::Base> + Inherits<Object>> CastToScript<T> fo
     }
 }
 
+/// Script property access indirection
+///
+/// gdext uses this kind of indirection to allow conversion of the actual property value into a godot compatible type when accessing the
+/// property from the engine. This Trait separates the `::godot::prelude::Var` trait into it's get and set components for more granular
+/// requirements on the property types.
+pub trait GetScriptProperty: GodotConvert {
+    fn get_property(&self) -> Self::Via;
+}
+
+/// Script property write indirection
+///
+/// gdext uses this kind of indirection to allow conversion of the actual property value from a godot compatible type when setting the
+/// property from the engine. This Trait separates the `::godot::prelude::Var` trait into it's get and set components for more granular
+/// requirements on the property types.
+pub trait SetScriptProperty: GodotConvert {
+    fn set_property(&mut self, value: Self::Via);
+}
+
+/// Unified property init strategy.
+///
+/// Most of the time we can initialize a script property with the `Default` trait. To support cases where `Default` is not implemented we
+/// can manually implement this trait.
+pub trait InitScriptProperty {
+    fn init_property() -> Self;
+}
+
+impl<T> GetScriptProperty for T
+where
+    T: godot::prelude::Var,
+{
+    fn get_property(&self) -> Self::Via {
+        T::get_property(self)
+    }
+}
+
+impl<T> SetScriptProperty for T
+where
+    T: godot::prelude::Var,
+{
+    fn set_property(&mut self, value: Self::Via) {
+        T::set_property(self, value);
+    }
+}
+
+impl<T> InitScriptProperty for T
+where
+    T: Default,
+{
+    fn init_property() -> Self {
+        Default::default()
+    }
+}
+
 #[macro_export]
 macro_rules! define_script_root {
     () => {

rust-script/src/interface/export.rs

@@ -15,14 +15,15 @@ use godot::builtin::{
 };
 use godot::classes::{Node, Resource};
 use godot::global::PropertyHint;
-use godot::meta::{ArrayElement, FromGodot, GodotConvert, GodotType, ToGodot};
+use godot::meta::{ArrayElement, GodotConvert, GodotType};
 use godot::obj::{EngineEnum, Gd};
 use godot::prelude::GodotClass;
+use godot::register::property::BuiltinExport;
 use godot::sys::GodotFfi;
 
-use super::{GodotScript, RsRef};
+use super::{GodotScript, OnEditor, RsRef};
 
-pub trait GodotScriptExport: GodotConvert + FromGodot + ToGodot {
+pub trait GodotScriptExport {
     fn hint_string(custom_hint: Option<PropertyHint>, custom_string: Option<String>) -> String;
 
     fn hint(custom: Option<PropertyHint>) -> PropertyHint;
@@ -78,11 +79,7 @@ impl<T: GodotScript> GodotScriptExport for RsRef<T> {
 
 impl<T: GodotScriptExport> GodotScriptExport for Option<T>
 where
-    for<'v> T: 'v,
-    for<'v> <<T as ToGodot>::ToVia<'v> as GodotType>::Ffi: godot::sys::GodotNullableFfi,
-    for<'f> <<T as GodotConvert>::Via as GodotType>::ToFfi<'f>: godot::sys::GodotNullableFfi,
-    <<T as GodotConvert>::Via as GodotType>::Ffi: godot::sys::GodotNullableFfi,
-    for<'v, 'f> <<T as ToGodot>::ToVia<'v> as GodotType>::ToFfi<'f>: godot::sys::GodotNullableFfi,
+    Self: GodotConvert + godot::prelude::Var,
 {
     fn hint_string(custom_hint: Option<PropertyHint>, custom_string: Option<String>) -> String {
         T::hint_string(custom_hint, custom_string)
@@ -113,6 +110,21 @@ impl<T: ArrayElement + GodotScriptExport + GodotType> GodotScriptExport for Arra
     }
 }
 
+impl<T: GodotScriptExport> GodotScriptExport for OnEditor<T>
+where
+    Self: GodotConvert + godot::prelude::Var,
+{
+    fn hint_string(custom_hint: Option<PropertyHint>, custom_string: Option<String>) -> String {
+        T::hint_string(custom_hint, custom_string)
+    }
+
+    fn hint(custom: Option<PropertyHint>) -> PropertyHint {
+        T::hint(custom)
+    }
+}
+
+impl<T: GodotScript> BuiltinExport for RsRef<T> {}
+
 macro_rules! default_export {
     ($ty:ty) => {
         impl GodotScriptExport for $ty {
@@ -193,7 +205,6 @@ default_export!(i8);
 default_export!(u32);
 default_export!(u16);
 default_export!(u8);
-default_export!(u64);
 
 default_export!(Callable);
 default_export!(godot::builtin::Signal);

rust-script/src/interface/on_editor.rs

@@ -0,0 +1,90 @@
+/*
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ */
+
+use std::{
+    any::type_name,
+    ops::{Deref, DerefMut},
+};
+
+use godot::{
+    classes::class_macros::sys::GodotNullableFfi,
+    meta::{FromGodot, GodotConvert, GodotType, ToGodot},
+};
+
+#[derive(Debug)]
+enum ValueState<T> {
+    Invalid,
+    Valid(T),
+}
+
+#[derive(Debug)]
+pub struct OnEditor<T> {
+    value: ValueState<T>,
+}
+
+impl<T> Default for OnEditor<T> {
+    fn default() -> Self {
+        Self {
+            value: ValueState::Invalid,
+        }
+    }
+}
+
+impl<T: GodotConvert> GodotConvert for OnEditor<T>
+where
+    for<'a> <T::Via as GodotType>::ToFfi<'a>: GodotNullableFfi,
+    <T::Via as GodotType>::Ffi: GodotNullableFfi,
+{
+    type Via = Option<T::Via>;
+}
+
+impl<T> godot::prelude::Var for OnEditor<T>
+where
+    for<'v> T: ToGodot<ToVia<'v> = <T as GodotConvert>::Via> + FromGodot + 'v,
+    Self: GodotConvert<Via = Option<T::Via>>,
+{
+    fn get_property(&self) -> Self::Via {
+        match self.value {
+            ValueState::Invalid => None,
+            ValueState::Valid(ref value) => Some(value.to_godot()),
+        }
+    }
+
+    fn set_property(&mut self, value: Self::Via) {
+        match value {
+            Some(value) => self.value = ValueState::Valid(T::from_godot(value)),
+            None => self.value = ValueState::Invalid,
+        }
+    }
+}
+
+impl<T> Deref for OnEditor<T> {
+    type Target = T;
+
+    fn deref(&self) -> &Self::Target {
+        match self.value {
+            ValueState::Invalid => panic!(
+                "OnEditor property of type {} is uninitialized!",
+                type_name::<T>()
+            ),
+
+            ValueState::Valid(ref value) => value,
+        }
+    }
+}
+
+impl<T> DerefMut for OnEditor<T> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        match self.value {
+            ValueState::Invalid => panic!(
+                "OnEditor property of type {} is uninitialized!",
+                type_name::<T>()
+            ),
+
+            ValueState::Valid(ref mut value) => value,
+        }
+    }
+}

rust-script/src/interface/signals.rs

@@ -17,6 +17,8 @@ use godot::obj::{Gd, GodotClass};
 use crate::static_script_registry::RustScriptPropDesc;
 use crate::{GodotScript, RsRef};
 
+use super::GetScriptProperty;
+
 pub trait SignalArguments {
     const COUNT: u8;
 
@@ -220,3 +222,9 @@ impl<T: SignalArguments> ToGodot for ScriptSignal<T> {
         godot::builtin::Signal::from_object_signal(&self.host, self.name)
     }
 }
+
+impl<T: SignalArguments> GetScriptProperty for ScriptSignal<T> {
+    fn get_property(&self) -> Self::Via {
+        self.to_godot()
+    }
+}

rust-script/tests/script_derive.rs

@@ -8,7 +8,8 @@ use godot::builtin::{Array, GString};
 use godot::classes::{Node, Node3D};
 use godot::obj::{Gd, NewAlloc};
 use godot_rust_script::{
-    godot_script_impl, CastToScript, Context, GodotScript, GodotScriptEnum, RsRef, ScriptSignal,
+    godot_script_impl, CastToScript, Context, GodotScript, GodotScriptEnum, OnEditor, RsRef,
+    ScriptSignal,
 };
 
 #[derive(Debug, Default, GodotScriptEnum)]
@@ -48,6 +49,9 @@ struct TestScript {
     #[export(ty = "Decal")]
     pub node_prop_2: Option<Gd<Node3D>>,
 
+    #[export(ty = "Decal")]
+    pub node_prop_3: OnEditor<Gd<Node3D>>,
+
     #[export]
     pub node_array: Array<Gd<Node3D>>,
 
@@ -57,6 +61,11 @@ struct TestScript {
     #[export]
     pub custom_enum: ScriptEnum,
 
+    #[export]
+    pub script_ref_opt: Option<RsRef<TestScript>>,
+
+    #[export]
+    pub script_ref: OnEditor<RsRef<TestScript>>,
     base: Gd<<Self as GodotScript>::Base>,
 }