handle 3D Transforms, reorder some conditions, add another TODO

Author: Waridley

gdnative-core/src/core_types/variant/serde.rs

@@ -416,7 +416,7 @@ impl<'de> Visitor<'de> for VariantVisitor {
                 }
             }
         } else if len == 2 {
-            if let Some(v) = vec2_plane_rect2_or_aabb(&dict) {
+            if let Some(v) = vec2_plane_xform_rect2_or_aabb(&dict) {
                 return Ok(v);
             }
         } else if len == 3 {
@@ -456,19 +456,17 @@ fn basis_seq<Access: ThreadAccess>(arr: &VariantArray<Access>, first: Vector3) -
 
 fn string_tagged(key: &str, value: Variant) -> Option<Variant> {
     let s = key;
-    if s == value.get_type().name() {
+    let value_type = value.get_type();
+    if (s == value_type.name())
+        || ((value_type == Option::<()>::None.to_variant().get_type()) && (s == "Object"))
+        || ((value_type == ().to_variant().get_type()) && (s == "Rid"))
+        //maybe a Basis represented as a Map, in which case visit_seq will have assumed [Vector3; 3] was a Basis
+        || ((value_type == VariantType::Basis) && (s == "elements"))
+    {
         return Some(value);
-    } else if s == "elements" {
-        //maybe a Basis represented as a Map
-        if let VariantType::Basis = value.get_type() {
-            //visit_seq will have assumed [Vector3; 3] was a Basis
-            return Some(value);
-        }
-    } else if value.get_type() == ().to_variant().get_type() {
-        match &*s {
-            "Object" => return Some(Variant::new()),
-            "Rid" => return Some(Rid::new().to_variant()),
-            _ => {}
+    } else if s == VariantType::NodePath.name() {
+        if let Some(path) = value.try_to_string() {
+            return Some(NodePath::from_str(&*path).to_variant());
         }
     } else if let Some(arr) = value.try_to_array() {
         if let Some(s) = s.strip_suffix("Array") {
@@ -488,15 +486,22 @@ fn string_tagged(key: &str, value: Variant) -> Option<Variant> {
 }
 
 fn int_tagged(key: i64, value: Variant) -> Option<Variant> {
+    //TODO: The field enums serde generates for structs could get stored as ints.
+    // We could either hand-write all the impls so we know what the int will be,
+    // or assume serde will keep the indices the same as the declaration order,
+    // or just not support deserializing Variants from formats that store the field
+    // identifier as an int (VariantDispatch should still work).
     let i = key;
     if i == value.get_type() as i64 {
         return Some(value);
-    } else if value.get_type() == ().to_variant().get_type() {
-        if i == VariantType::Object as i64 {
-            return Some(Variant::new());
-        } else if i == VariantType::Rid as i64 {
-            return Some(Rid::new().to_variant());
-        }
+    } else if (i == VariantType::Object as i64)
+        && (value.get_type() == ().to_variant().get_type())
+    {
+        return Some(Variant::new());
+    } else if (i == VariantType::Rid as i64)
+        && (value.get_type() == Option::<()>::None.to_variant().get_type())
+    {
+        return Some(Rid::new().to_variant());
     } else if let Some(arr) = value.try_to_array() {
         if i == VariantType::ByteArray as i64 {
             return Some(ByteArray::from_variant_array(&arr).to_variant());
@@ -515,17 +520,20 @@ fn int_tagged(key: i64, value: Variant) -> Option<Variant> {
     None
 }
 
-fn vec2_plane_rect2_or_aabb(dict: &Dictionary<Unique>) -> Option<Variant> {
+fn vec2_plane_xform_rect2_or_aabb(dict: &Dictionary<Unique>) -> Option<Variant> {
     if let Some(x) = get_f32(&dict, "x") {
         if let Some(y) = get_f32(&dict, "y") {
             return Some(Vector2 { x, y }.to_variant());
         }
-    } else {
-        if let Some(normal) = dict.get("normal").try_to_vector3() {
-            if let Some(d) = get_f32(&dict, "d") {
-                return Some(Plane { normal, d }.to_variant());
-            }
+    } else if let Some(normal) = dict.get("normal").try_to_vector3() {
+        if let Some(d) = get_f32(&dict, "d") {
+            return Some(Plane { normal, d }.to_variant());
         }
+    } else if let Some(basis) = dict.get("basis").try_to_basis() {
+        if let Some(origin) = dict.get("origin").try_to_vector3() {
+            return Some(Transform { basis, origin }.to_variant());
+        }
+    } else {
         match dict.get("position").dispatch() {
             VariantDispatch::Vector2(position) => {
                 if let Some(size) = dict.get("size").try_to_vector2() {