Merge #154

154: Exports: add PropertyHints as optional Parameters r=Bromeon a=mio991

As the title says I added PropertyHints as optional Parameters.

If you prefere another design tell me.

Co-authored-by: mio991 <[email protected]>

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

@@ -31,6 +31,8 @@ pub trait VariantMetadata {
             Self::variant_type(),
             Self::class_name(),
             StringName::from(property_name),
+            global::PropertyHint::PROPERTY_HINT_NONE,
+            GodotString::new(),
         )
     }
 
@@ -64,13 +66,15 @@ impl PropertyInfo {
         variant_type: VariantType,
         class_name: ClassName,
         property_name: StringName,
+        hint: global::PropertyHint,
+        hint_string: GodotString,
     ) -> Self {
         Self {
             variant_type,
             class_name,
             property_name,
-            hint: global::PropertyHint::PROPERTY_HINT_NONE,
-            hint_string: GodotString::new(),
+            hint,
+            hint_string,
             usage: global::PropertyUsageFlags::PROPERTY_USAGE_DEFAULT,
         }
     }

godot-macros/src/derive_godot_class.rs

@@ -176,17 +176,44 @@ struct ExportedField {
     field: Field,
     getter: String,
     setter: String,
+    hint: Option<ExportHint>,
+}
+
+#[derive(Clone)]
+struct ExportHint {
+    hint_type: Ident,
+    description: String,
+}
+
+impl ExportHint {
+    fn none() -> Self {
+        Self {
+            hint_type: ident("PROPERTY_HINT_NONE"),
+            description: "".to_string(),
+        }
+    }
 }
 
 impl ExportedField {
     pub fn new_from_kv(field: Field, parser: &mut KvParser) -> ParseResult<ExportedField> {
         let getter = parser.handle_lit_required("getter")?;
         let setter = parser.handle_lit_required("setter")?;
 
+        let hint = parser
+            .handle_ident("hint")?
+            .map(|hint_type| {
+                Ok(ExportHint {
+                    hint_type,
+                    description: parser.handle_lit_required("hint_desc")?,
+                })
+            })
+            .transpose()?;
+
         Ok(ExportedField {
             field,
             getter,
             setter,
+            hint,
         })
     }
 }
@@ -248,6 +275,14 @@ fn make_exports_impl(class_name: &Ident, fields: &Fields) -> TokenStream {
             let setter = proc_macro2::Literal::from_str(&exported_field.setter).unwrap();
             let field_type = exported_field.field.ty.clone();
 
+            let ExportHint {
+                hint_type,
+                description,
+            } = exported_field.hint.clone().unwrap_or_else(ExportHint::none);
+
+            // trims '"' and '\' from both ends of the hint description.
+            let description = description.trim_matches(|c| c == '\\' || c == '"');
+
             quote! {
                 use ::godot::builtin::meta::VariantMetadata;
 
@@ -256,6 +291,8 @@ fn make_exports_impl(class_name: &Ident, fields: &Fields) -> TokenStream {
                     <#field_type>::variant_type(),
                     ::godot::builtin::meta::ClassName::of::<#class_name>(),
                     ::godot::builtin::StringName::from(#name),
+                    ::godot::engine::global::PropertyHint::#hint_type,
+                    GodotString::from(#description),
                 );
                 let property_info_sys = property_info.property_sys();
 

itest/godot/ManualFfiTests.gd

@@ -35,7 +35,16 @@ func test_export():
 	var node = Node.new()
 	obj.object_val = node
 	assert_eq(obj.object_val, node)
-
+
+	var texture_val_meta = obj.get_property_list().filter(
+		func(el)->bool:
+			return el["name"] == "texture_val"
+			).front()
+
+	assert_that(texture_val_meta != null, "'texture_val' is defined")
+	assert_eq(texture_val_meta["hint"], PropertyHint.PROPERTY_HINT_RESOURCE_TYPE)
+	assert_eq(texture_val_meta["hint_string"], "Texture")
+
 	obj.free()
 	node.free()
 

itest/rust/src/export_test.rs

@@ -4,7 +4,7 @@
  * file, You can obtain one at https://mozilla.org/MPL/2.0/.
  */
 
-use godot::prelude::*;
+use godot::{engine::Texture, prelude::*};
 
 // No tests currently, tests using HasProperty are in Godot scripts.
 
@@ -19,6 +19,8 @@ struct HasProperty {
     string_val: GodotString,
     #[export(getter = "get_object_val", setter = "set_object_val")]
     object_val: Option<Gd<Object>>,
+    #[export(getter = "get_texture_val", setter = "set_texture_val", hint = PROPERTY_HINT_RESOURCE_TYPE, hint_desc = "Texture")]
+    texture_val: Option<Gd<Texture>>,
 }
 
 #[godot_api]
@@ -56,6 +58,20 @@ impl HasProperty {
     pub fn set_object_val(&mut self, val: Gd<Object>) {
         self.object_val = Some(val);
     }
+
+    #[func]
+    pub fn get_texture_val(&self) -> Variant {
+        if let Some(texture_val) = self.texture_val.as_ref() {
+            texture_val.to_variant()
+        } else {
+            Variant::nil()
+        }
+    }
+
+    #[func]
+    pub fn set_texture_val(&mut self, val: Gd<Texture>) {
+        self.texture_val = Some(val);
+    }
 }
 
 #[godot_api]
@@ -65,6 +81,7 @@ impl GodotExt for HasProperty {
             int_val: 0,
             object_val: None,
             string_val: GodotString::new(),
+            texture_val: None,
             base,
         }
     }