Add GodotObject serialization support

Author: Waridley

gdnative-bindings/Cargo.toml

@@ -19,6 +19,7 @@ gdnative-sys = { path = "../gdnative-sys", version = "0.9.3" }
 gdnative-core = { path = "../gdnative-core", version = "=0.9.3" }
 libc = "0.2"
 bitflags = "1.2"
+serde = { version = "1.0", default_features = false, features = ["derive"], optional = true }
 
 [build-dependencies]
 heck = "0.3.0"

gdnative-bindings/src/lib.rs

@@ -11,3 +11,8 @@ pub use generated::*;
 pub mod utils;
 
 pub(crate) mod icalls;
+
+#[cfg(feature = "serde")]
+mod serde;
+#[cfg(feature = "serde")]
+use serde::{DeserializedObject, SerializableObject};

gdnative-bindings/src/serde.rs

@@ -0,0 +1,158 @@
+use crate::Object;
+use gdnative_core::core_types::{GodotString, Variant};
+use gdnative_core::object::{Instanciable, RefImplBound, SafeDeref, SubClass};
+use gdnative_core::thread_access::Unique;
+use gdnative_core::{GodotObject, NewRef, Ref};
+use serde::de::{MapAccess, Visitor};
+use serde::ser::SerializeStruct;
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
+use std::fmt::Formatter;
+use std::marker::PhantomData;
+use std::ops::Deref;
+
+//TODO: Optimize (by adding names to a static HashSet?) instead of leaking so many strings
+
+impl Serialize for Object {
+    #[inline]
+    fn serialize<S>(&self, ser: S) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>
+    where
+        S: Serializer,
+    {
+        let name = Box::leak(self.get_class().to_string().into_boxed_str());
+        let arr = self.get_property_list();
+        let mut ser = ser.serialize_struct(name, arr.len() as usize)?;
+        for dict in arr.iter().map(|v| v.to_dictionary()) {
+            let name = dict.get("name").to_godot_string();
+            let value = self.get(name.new_ref());
+            let name = Box::leak(name.to_string().into_boxed_str());
+            ser.serialize_field(&*name, &value)?
+        }
+        ser.end()
+    }
+}
+
+/// Newtype that allows serializing all properties of an instance of a Godot class, skipping
+/// properties that are set to their default values. This can be used in conjunction with an
+/// [EditorImportPlugin] or custom engine module to mimic Godot's `tres` files while using a
+/// different syntax.
+pub struct SerializableObject<'a, T: GodotObject>(&'a T);
+
+// Unfortunately, Rust's orphan rules won't allow us to `impl Deserialize` directly for `&T`,
+// and `Object` is defined in this crate, not in `gdnative_core`. Thus we can't add `SubClass<Object>`
+// bounds in `gdnative_core`, and we can only `impl Serialize` on a newtype here.
+impl<'a, T: Instanciable + SubClass<Object>> Serialize for SerializableObject<'a, T>
+where
+    RefImplBound: SafeDeref<T::RefKind, Unique>,
+{
+    fn serialize<S>(&self, serializer: S) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>
+    where
+        S: Serializer,
+    {
+        let obj = self.0.upcast::<Object>();
+        let name = Box::leak(obj.get_class().to_string().into_boxed_str());
+        let default = T::new();
+
+        let mut fields = Vec::new();
+
+        for v in obj.get_property_list().iter() {
+            let dict = v.to_dictionary();
+            let gd_name = dict.get("name").to_godot_string();
+            let value = obj.get(gd_name.new_ref());
+            let def_val = default.as_ref().upcast::<Object>().get(gd_name.new_ref());
+            if value != def_val {
+                let name = &*Box::leak(gd_name.to_string().into_boxed_str());
+                fields.push((name, value));
+            }
+        }
+        let mut ser = serializer.serialize_struct(name, fields.len())?;
+        for (name, value) in &fields {
+            ser.serialize_field(*name, value)?
+        }
+        ser.end()
+    }
+}
+
+/// Unfortunately, Rust's orphan rules won't allow us to `impl Deserialize for Ref<T, Unique>` from
+/// this crate, and `Object` is defined in this crate, not in `gdnative_core`.
+/// Thus we can't add `SubClass<Object>` bounds in `gdnative_core`, and we can only implement
+/// `Deserialize` on a newtype here.
+pub struct DeserializedObject<T: GodotObject>(pub Ref<T, Unique>);
+
+impl<T: GodotObject> Deref for DeserializedObject<T> {
+    type Target = Ref<T, Unique>;
+
+    #[inline]
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+impl<'de, T: Instanciable + SubClass<Object>> Deserialize<'de> for DeserializedObject<T>
+where
+    RefImplBound: SafeDeref<T::RefKind, Unique>,
+{
+    #[inline]
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        struct ObjectVisitor<T>(PhantomData<T>);
+
+        impl<'de, T: Instanciable + SubClass<Object>> Visitor<'de> for ObjectVisitor<T>
+        where
+            RefImplBound: SafeDeref<T::RefKind, Unique>,
+        {
+            type Value = Ref<T, Unique>;
+
+            fn expecting(&self, formatter: &mut Formatter) -> std::fmt::Result {
+                write!(
+                    formatter,
+                    "struct {}",
+                    T::new().as_ref().upcast::<Object>().get_class()
+                )
+            }
+
+            fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error>
+            where
+                A: MapAccess<'de>,
+            {
+                let t = T::new();
+                let obj = t.as_ref().upcast::<Object>();
+                while let Some((key, value)) = map.next_entry::<GodotString, Variant>()? {
+                    obj.set(key, value);
+                }
+
+                Ok(t)
+            }
+        }
+
+        let t = T::new();
+
+        let name = Box::leak(
+            t.as_ref()
+                .upcast::<Object>()
+                .get_class()
+                .to_string()
+                .into_boxed_str(),
+        );
+
+        let fields = unsafe {
+            &*Box::leak(
+                t.as_ref()
+                    .upcast::<Object>()
+                    .get_property_list()
+                    .iter()
+                    .map(|v| {
+                        let name = v.to_dictionary().get("name").to_string();
+                        &*Box::leak(name.into_boxed_str())
+                    })
+                    .collect::<Vec<_>>()
+                    .into_boxed_slice(),
+            )
+        };
+
+        deserializer
+            .deserialize_struct(name, fields, ObjectVisitor::<T>(PhantomData))
+            .map(DeserializedObject)
+    }
+}

gdnative/Cargo.toml

@@ -14,7 +14,7 @@ edition = "2018"
 [features]
 default = ["bindings"]
 formatted = ["gdnative-bindings/formatted", "gdnative-bindings/one_class_one_file"]
-serde = ["gdnative-core/serde"]
+serde = ["gdnative-core/serde", "gdnative-bindings/serde"]
 
 gd_test = ["gdnative-core/gd_test"]
 type_tag_fallback = ["gdnative-core/type_tag_fallback"]