Implement Export for Vec, HashMap, HashSet + new example

Author: ironpeak

Cargo.toml

@@ -17,6 +17,7 @@ members = [
     "examples/native-plugin",
     "examples/rpc",
     "examples/array-export",
+    "examples/collection-properties",
     "impl/proc-macros"
 ]
 

examples/collection-properties/Cargo.toml

@@ -0,0 +1,14 @@
+[package]
+name = "collection-properties"
+version = "0.1.0"
+authors = ["The godot-rust developers"]
+publish = false
+edition = "2021"
+rust-version = "1.56"
+license = "MIT"
+
+[lib]
+crate-type = ["cdylib"]
+
+[dependencies]
+gdnative = { path = "../../gdnative" }

examples/collection-properties/Main.tscn

@@ -0,0 +1,35 @@
+[gd_scene load_steps=5 format=2]
+
+[ext_resource path="res://collection_properties_library.gdnlib" type="GDNativeLibrary" id=1]
+
+[sub_resource type="NativeScript" id=1]
+resource_name = "ExampleHashMapProperty"
+class_name = "ExampleHashMapProperty"
+library = ExtResource( 1 )
+
+[sub_resource type="NativeScript" id=2]
+resource_name = "ExampleHashSetProperty"
+class_name = "ExampleHashSetProperty"
+library = ExtResource( 1 )
+
+[sub_resource type="NativeScript" id=3]
+resource_name = "ExampleVecProperty"
+class_name = "ExampleVecProperty"
+library = ExtResource( 1 )
+
+[node name="Node" type="Node"]
+
+[node name="HashMap" type="Node" parent="."]
+script = SubResource( 1 )
+players = {
+0: "Player0",
+1: "Player1"
+}
+
+[node name="HashSet" type="Node" parent="."]
+script = SubResource( 2 )
+players = [ "Player0", "Player0", "Player1" ]
+
+[node name="Vec" type="Node" parent="."]
+script = SubResource( 3 )
+players = [ "Player0", "Player1" ]

examples/collection-properties/collection_properties_library.gdnlib

@@ -0,0 +1,17 @@
+[entry]
+
+X11.64="res://../../target/debug/libcollection_properties.so"
+OSX.64="res://../../target/debug/libcollection_properties.dylib"
+Windows.64="res://../../target/debug/collection_properties.dll"
+
+[dependencies]
+
+X11.64=[  ]
+OSX.64=[  ]
+
+[general]
+
+singleton=false
+load_once=true
+symbol_prefix="godot_"
+reloadable=true

examples/collection-properties/default_env.tres

@@ -0,0 +1,14 @@
+[gd_resource type="Environment" load_steps=2 format=2]
+
+[sub_resource type="ProceduralSky" id=1]
+sky_top_color = Color( 0.0470588, 0.454902, 0.976471, 1 )
+sky_horizon_color = Color( 0.556863, 0.823529, 0.909804, 1 )
+sky_curve = 0.25
+ground_bottom_color = Color( 0.101961, 0.145098, 0.188235, 1 )
+ground_horizon_color = Color( 0.482353, 0.788235, 0.952941, 1 )
+ground_curve = 0.01
+sun_energy = 16.0
+
+[resource]
+background_mode = 2
+background_sky = SubResource( 1 )

examples/collection-properties/icon.png

@@ -0,0 +1,35 @@
+[remap]
+
+importer="texture"
+type="StreamTexture"
+path="res://.import/icon.png-487276ed1e3a0c39cad0279d744ee560.stex"
+metadata={
+"vram_texture": false
+}
+
+[deps]
+
+source_file="res://icon.png"
+dest_files=[ "res://.import/icon.png-487276ed1e3a0c39cad0279d744ee560.stex" ]
+
+[params]
+
+compress/mode=0
+compress/lossy_quality=0.7
+compress/hdr_mode=0
+compress/bptc_ldr=0
+compress/normal_map=0
+flags/repeat=0
+flags/filter=true
+flags/mipmaps=false
+flags/anisotropic=false
+flags/srgb=2
+process/fix_alpha_border=true
+process/premult_alpha=false
+process/HDR_as_SRGB=false
+process/invert_color=false
+process/normal_map_invert_y=false
+stream=false
+size_limit=0
+detect_3d=true
+svg/scale=1.0

examples/collection-properties/icon.png.import

@@ -0,0 +1,23 @@
+; Engine configuration file.
+; It's best edited using the editor UI and not directly,
+; since the parameters that go here are not all obvious.
+;
+; Format:
+;   [section] ; section goes between []
+;   param=value ; assign values to parameters
+
+config_version=4
+
+_global_script_classes=[  ]
+_global_script_class_icons={
+}
+
+[application]
+
+config/name="Godot Rust - Collection Properties"
+run/main_scene="res://Main.tscn"
+config/icon="res://icon.png"
+
+[rendering]
+
+environment/default_environment="res://default_env.tres"

examples/collection-properties/project.godot

@@ -0,0 +1,90 @@
+use gdnative::api::*;
+use gdnative::prelude::*;
+
+use std::collections::{HashMap, HashSet};
+
+// HashMap
+#[derive(NativeClass, Default)]
+#[inherit(Node)]
+pub struct ExampleHashMapProperty {
+    #[property]
+    players: HashMap<i64, String>,
+}
+
+impl ExampleHashMapProperty {
+    fn new(_owner: &Node) -> Self {
+        Self::default()
+    }
+}
+
+#[methods]
+impl ExampleHashMapProperty {
+    #[export]
+    fn _ready(&self, _owner: &Node) {
+        godot_print!("HashMap:");
+        for (id, name) in &self.players {
+            godot_print!("Hello, {} - {}!", id, name);
+        }
+    }
+}
+
+// HashSet
+#[derive(NativeClass, Default)]
+#[inherit(Node)]
+pub struct ExampleHashSetProperty {
+    #[property]
+    players: HashSet<String>,
+}
+
+impl ExampleHashSetProperty {
+    fn new(_owner: &Node) -> Self {
+        Self::default()
+    }
+}
+
+#[methods]
+impl ExampleHashSetProperty {
+    #[export]
+    fn _ready(&self, _owner: &Node) {
+        godot_print!("HashSet:");
+        for name in &self.players {
+            godot_print!("Hello, {}!", name);
+        }
+    }
+}
+
+// Vec
+#[derive(NativeClass, Default)]
+#[inherit(Node)]
+pub struct ExampleVecProperty {
+    #[property]
+    players: Vec<String>,
+}
+
+impl ExampleVecProperty {
+    fn new(_owner: &Node) -> Self {
+        Self::default()
+    }
+}
+
+#[methods]
+impl ExampleVecProperty {
+    #[export]
+    fn _ready(&self, _owner: &Node) {
+        godot_print!("Vec:");
+        for name in &self.players {
+            godot_print!("Hello, {}!", name);
+        }
+    }
+}
+
+// Function that registers all exposed classes to Godot
+fn init(handle: InitHandle) {
+    // Register the new `HelloWorld` type we just declared.
+    handle.add_class::<ExampleHashMapProperty>();
+    handle.add_class::<ExampleHashSetProperty>();
+    handle.add_class::<ExampleVecProperty>();
+}
+
+// Macro that creates the entry-points of the dynamic library.
+godot_init!(init);

examples/collection-properties/src/lib.rs

@@ -1,6 +1,6 @@
 use crate::*;
 use std::borrow::Cow;
-use std::collections::HashMap;
+use std::collections::{HashMap, HashSet};
 use std::default::Default;
 use std::fmt;
 use std::hash::Hash;
@@ -1632,6 +1632,38 @@ impl<K: FromVariant + Hash + Eq, V: FromVariant> FromVariant for HashMap<K, V> {
     }
 }
 
+impl<T: ToVariant> ToVariant for HashSet<T> {
+    #[inline]
+    fn to_variant(&self) -> Variant {
+        let array = VariantArray::new();
+        for value in self {
+            array.push(value.to_variant());
+        }
+        array.owned_to_variant()
+    }
+}
+
+impl<T: Eq + std::hash::Hash + FromVariant> FromVariant for HashSet<T> {
+    #[inline]
+    fn from_variant(variant: &Variant) -> Result<Self, FromVariantError> {
+        let arr = VariantArray::from_variant(variant)?;
+        let len: usize = arr
+            .len()
+            .try_into()
+            .expect("VariantArray length should fit in usize");
+        let mut set = HashSet::with_capacity(len);
+        for idx in 0..len as i32 {
+            let item =
+                T::from_variant(&arr.get(idx)).map_err(|e| FromVariantError::InvalidItem {
+                    index: idx as usize,
+                    error: Box::new(e),
+                })?;
+            set.insert(item);
+        }
+        Ok(set)
+    }
+}
+
 macro_rules! tuple_length {
     () => { 0usize };
     ($_x:ident, $($xs:ident,)*) => {
@@ -1836,6 +1868,63 @@ godot_test!(
         );
     }
 
+    test_variant_hash_set {
+        let original_hash_set = HashSet::from([
+            "Foo".to_string(),
+            "Bar".to_string(),
+        ]);
+        let variant = original_hash_set.to_variant();
+        let check_hash_set = variant.try_to::<HashSet<String>>().expect("should be hash set");
+        assert_eq!(original_hash_set, check_hash_set);
+
+        let duplicate_variant_set = VariantArray::new();
+        duplicate_variant_set.push("Foo".to_string());
+        duplicate_variant_set.push("Bar".to_string());
+        duplicate_variant_set.push("Bar".to_string());
+        let duplicate_hash_set = variant.try_to::<HashSet<String>>().expect("should be hash set");
+        assert_eq!(original_hash_set, duplicate_hash_set);
+
+        // Check conversion of heterogeneous set types
+        let non_homogenous_set = VariantArray::new();
+        non_homogenous_set.push("Foo".to_string());
+        non_homogenous_set.push(7);
+        assert_eq!(
+            non_homogenous_set.owned_to_variant().try_to::<HashSet<String>>(),
+            Err(FromVariantError::InvalidItem {
+                index: 1,
+                error: Box::new(FromVariantError::InvalidVariantType {
+                    variant_type: VariantType::I64,
+                    expected: VariantType::GodotString
+                })
+            }),
+        );
+    }
+
+    test_variant_vec {
+        let original_vec = Vec::from([
+            "Foo".to_string(),
+            "Bar".to_string(),
+        ]);
+        let variant = original_vec.to_variant();
+        let check_vec = variant.try_to::<Vec<String>>().expect("should be hash set");
+        assert_eq!(original_vec, check_vec);
+
+        // Check conversion of heterogeneous vec types
+        let non_homogenous_vec = VariantArray::new();
+        non_homogenous_vec.push("Foo".to_string());
+        non_homogenous_vec.push(7);
+        assert_eq!(
+            non_homogenous_vec.owned_to_variant().try_to::<Vec<String>>(),
+            Err(FromVariantError::InvalidItem {
+                index: 1,
+                error: Box::new(FromVariantError::InvalidVariantType {
+                    variant_type: VariantType::I64,
+                    expected: VariantType::GodotString
+                })
+            }),
+        );
+    }
+
     test_variant_tuple {
         let variant = (42i64, 54i64).to_variant();
         let arr = variant.try_to::<VariantArray>().expect("should be array");