Added an #[export()] attribute to GDClass members.

No support currently for any VariantTypes other than ints.

Author: mhoff12358

godot-core/src/obj/traits.rs

@@ -100,6 +100,11 @@ pub mod cap {
         fn __register_methods();
     }
 
+    pub trait ImplementsGodotExports: GodotClass {
+        #[doc(hidden)]
+        fn __register_exports();
+    }
+
     /// Auto-implemented for `#[godot_api] impl GodotExt for MyClass` blocks
     pub trait ImplementsGodotExt: GodotClass {
         #[doc(hidden)]

godot-core/src/registry.rs

@@ -374,13 +374,16 @@ pub mod callbacks {
         T::register_class(&mut class_builder);
     }
 
-    pub fn register_user_binds<T: cap::ImplementsGodotApi>(_class_builder: &mut dyn Any) {
+    pub fn register_user_binds<T: cap::ImplementsGodotApi + cap::ImplementsGodotExports>(
+        _class_builder: &mut dyn Any,
+    ) {
         // let class_builder = class_builder
         //     .downcast_mut::<ClassBuilder<T>>()
         //     .expect("bad type erasure");
 
         //T::register_methods(class_builder);
         T::__register_methods();
+        T::__register_exports();
     }
 }
 

godot-macros/src/derive_godot_class.rs

@@ -4,7 +4,9 @@
  * file, You can obtain one at https://mozilla.org/MPL/2.0/.
  */
 
-use crate::util::{bail, ensure_kv_empty, ident, path_is_single, KvMap, KvValue};
+use crate::util::{
+    bail, bail_error, ensure_kv_empty, ident, parse_kv_group, path_is_single, KvMap, KvValue,
+};
 use crate::{util, ParseResult};
 use proc_macro2::{Ident, Punct, Span, TokenStream};
 use quote::spanned::Spanned;
@@ -30,6 +32,8 @@ pub fn transform(input: TokenStream) -> ParseResult<TokenStream> {
     let prv = quote! { ::godot::private };
     let deref_impl = make_deref_impl(class_name, &fields);
 
+    let godot_exports_impl = make_exports_impl(class_name, &fields);
+
     let (godot_init_impl, create_fn);
     if struct_cfg.has_generated_init {
         godot_init_impl = make_godot_init_impl(class_name, fields);
@@ -49,6 +53,7 @@ pub fn transform(input: TokenStream) -> ParseResult<TokenStream> {
         }
 
         #godot_init_impl
+        #godot_exports_impl
         #deref_impl
 
         ::godot::sys::plugin_add!(__GODOT_PLUGIN_REGISTRY in #prv; #prv::ClassPlugin {
@@ -111,7 +116,7 @@ fn parse_struct_attributes(class: &Struct) -> ParseResult<ClassAttributes> {
 fn parse_fields(class: &Struct) -> ParseResult<Fields> {
     let mut all_field_names = vec![];
     let mut exported_fields = vec![];
-    let mut base_field = Option::<ExportedField>::None;
+    let mut base_field = Option::<Field>::None;
 
     let fields: Vec<(NamedField, Punct)> = match &class.fields {
         StructFields::Unit => {
@@ -142,9 +147,18 @@ fn parse_fields(class: &Struct) -> ParseResult<Fields> {
                             attr,
                         )?;
                     }
-                    base_field = Some(ExportedField::new(&field))
+                    base_field = Some(Field::new(&field))
                 } else if path == "export" {
-                    exported_fields.push(ExportedField::new(&field))
+                    match parse_kv_group(&attr.value) {
+                        Ok(export_kv) => {
+                            let exported_field =
+                                ExportedField::new_from_kv(Field::new(&field), &attr, export_kv)?;
+                            exported_fields.push(exported_field);
+                        }
+                        Err(error) => {
+                            return Err(error);
+                        }
+                    }
                 }
             }
         }
@@ -158,6 +172,7 @@ fn parse_fields(class: &Struct) -> ParseResult<Fields> {
     Ok(Fields {
         all_field_names,
         base_field,
+        exported_fields,
     })
 }
 
@@ -191,15 +206,16 @@ struct ClassAttributes {
 
 struct Fields {
     all_field_names: Vec<Ident>,
-    base_field: Option<ExportedField>,
+    base_field: Option<Field>,
+    exported_fields: Vec<ExportedField>,
 }
 
-struct ExportedField {
+struct Field {
     name: Ident,
     _ty: TyExpr,
 }
 
-impl ExportedField {
+impl Field {
     fn new(field: &NamedField) -> Self {
         Self {
             name: field.name.clone(),
@@ -208,8 +224,55 @@ impl ExportedField {
     }
 }
 
+struct ExportedField {
+    field: Field,
+    getter: String,
+    setter: String,
+}
+
+impl ExportedField {
+    pub fn new_from_kv(
+        field: Field,
+        attr: &Attribute,
+        mut map: KvMap,
+    ) -> Result<ExportedField, venial::Error> {
+        let export_getter: String;
+        let export_setter: String;
+        if let Some(getter) = map.remove("getter") {
+            if let KvValue::Lit(getter) = getter {
+                export_getter = getter;
+            } else {
+                return Err(bail_error(
+                    "#[property] attribute with a non-literal getter",
+                    attr,
+                ));
+            }
+        } else {
+            return Err(bail_error("#[property] attribute without a getter", attr));
+        }
+        if let Some(setter) = map.remove("setter") {
+            if let KvValue::Lit(setter) = setter {
+                export_setter = setter;
+            } else {
+                return Err(bail_error(
+                    "#[property] attribute with a non-literal setter",
+                    attr,
+                ));
+            }
+        } else {
+            return Err(bail_error("#[property] attribute without a setter", attr));
+        }
+        ensure_kv_empty(map, attr.__span())?;
+        return Ok(ExportedField {
+            field,
+            getter: export_getter,
+            setter: export_setter,
+        });
+    }
+}
+
 fn make_godot_init_impl(class_name: &Ident, fields: Fields) -> TokenStream {
-    let base_init = if let Some(ExportedField { name, .. }) = fields.base_field {
+    let base_init = if let Some(Field { name, .. }) = fields.base_field {
         quote! { #name: base, }
     } else {
         TokenStream::new()
@@ -232,7 +295,7 @@ fn make_godot_init_impl(class_name: &Ident, fields: Fields) -> TokenStream {
 }
 
 fn make_deref_impl(class_name: &Ident, fields: &Fields) -> TokenStream {
-    let base_field = if let Some(ExportedField { name, .. }) = &fields.base_field {
+    let base_field = if let Some(Field { name, .. }) = &fields.base_field {
         name
     } else {
         return TokenStream::new();
@@ -253,3 +316,47 @@ fn make_deref_impl(class_name: &Ident, fields: &Fields) -> TokenStream {
         }
     }
 }
+
+fn make_exports_impl(class_name: &Ident, fields: &Fields) -> TokenStream {
+    let export_tokens = fields
+        .exported_fields
+        .iter()
+        .map(|exported_field: &ExportedField| {
+            use std::str::FromStr;
+            let name = exported_field.field.name.to_string();
+            let getter = proc_macro2::Literal::from_str(&exported_field.getter).unwrap();
+            let setter = proc_macro2::Literal::from_str(&exported_field.setter).unwrap();
+            quote! {
+                let class_name = ::godot::builtin::StringName::from(#class_name::CLASS_NAME);
+                let property_info = ::godot::builtin::meta::PropertyInfo::new(
+                    ::godot::sys::VariantType::Int,
+                    ::godot::builtin::meta::ClassName::new::<#class_name>(),
+                    ::godot::builtin::StringName::from(#name),
+                );
+                let property_info_sys = property_info.property_sys();
+
+                let getter_string_name = ::godot::builtin::StringName::from(#getter);
+                let setter_string_name = ::godot::builtin::StringName::from(#setter);
+                unsafe {
+                    ::godot::sys::interface_fn!(classdb_register_extension_class_property)(
+                        ::godot::sys::get_library(),
+                        class_name.string_sys(),
+                        std::ptr::addr_of!(property_info_sys),
+                        setter_string_name.string_sys(),
+                        getter_string_name.string_sys(),
+                    );
+                }
+            }
+        });
+    quote! {
+        impl ::godot::obj::cap::ImplementsGodotExports for #class_name {
+            fn __register_exports() {
+                #(
+                    {
+                        #export_tokens
+                    }
+                )*
+            }
+        }
+    }
+}

godot-macros/src/util.rs

@@ -22,6 +22,13 @@ pub fn strlit(s: &str) -> Literal {
     Literal::string(s)
 }
 
+pub fn bail_error<T>(msg: impl AsRef<str>, tokens: T) -> Error
+where
+    T: Spanned,
+{
+    Error::new_at_span(tokens.__span(), msg.as_ref())
+}
+
 pub fn bail<R, T>(msg: impl AsRef<str>, tokens: T) -> Result<R, Error>
 where
     T: Spanned,

itest/godot/ManualFfiTests.gd

@@ -24,4 +24,10 @@ func test_to_string() -> bool:
 
 	print("to_string: ", s)
 	print("to_string: ", ffi)
-	return true
+	return true
+	
+func test_export() -> bool:
+	var obj = HasProperty.new()
+	obj.val = 5
+	print("[GD] HasProperty's property is: ", obj.val, " and should be 5")
+	return obj.val == 5

itest/rust/src/export_test.rs

@@ -0,0 +1,44 @@
+/*
+ * 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 https://mozilla.org/MPL/2.0/.
+ */
+
+use crate::itest;
+use godot::prelude::*;
+
+pub(crate) fn run() -> bool {
+    let mut ok = true;
+    // No tests currently, tests using HasProperty are in Godot scripts.
+
+    ok
+}
+
+#[derive(GodotClass)]
+#[class(base=Node)]
+struct HasProperty {
+    #[export(getter = "get_val", setter = "set_val")]
+    val: i32,
+    #[base]
+    base: Base<Node>,
+}
+
+#[godot_api]
+impl HasProperty {
+    #[func]
+    pub fn get_val(&self) -> i32 {
+        return self.val;
+    }
+
+    #[func]
+    pub fn set_val(&mut self, val: i32) {
+        self.val = val;
+    }
+}
+
+#[godot_api]
+impl GodotExt for HasProperty {
+    fn init(base: Base<Node>) -> Self {
+        HasProperty { val: 0, base }
+    }
+}

itest/rust/src/lib.rs

@@ -11,6 +11,7 @@ use std::panic::UnwindSafe;
 
 mod base_test;
 mod enum_test;
+mod export_test;
 mod gdscript_ffi_test;
 mod node_test;
 mod object_test;
@@ -27,6 +28,7 @@ fn run_tests() -> bool {
     ok &= node_test::run();
     ok &= enum_test::run();
     ok &= object_test::run();
+    ok &= export_test::run();
     ok &= singleton_test::run();
     ok &= string_test::run();
     ok &= utilities_test::run();