WIP migration: Add reflect de/serializer code from bevyengine/bevy#15482

Author: mbrea-c

Cargo.lock

@@ -16,3 +16,4 @@ serde = { version = "1.0.193", features = ["derive", "rc"] }
 indexmap = { version = "2.2.1", features = ["serde"] }
 regex = "1.10.3"
 uuid = "1.0"
+rmp-serde = "1.3.0"

crates/bevy_animation_graph/Cargo.toml

@@ -4,8 +4,8 @@ use super::{pin, AnimationGraph, Extra};
 use crate::{
     prelude::{AnimationNode, DataSpec, DataValue, NodeLike, ReflectNodeLike},
     utils::{
-        reflect_de::{TypedReflectDeserializer, ValueProcessor},
-        reflect_ser::{ReflectSerializerProcessor, TypedReflectSerializer},
+        de::TypedReflectDeserializer,
+        ser::{ReflectSerializerProcessor, TypedReflectSerializer},
     },
 };
 use bevy::{
@@ -172,7 +172,7 @@ impl<'de> DeserializeSeed<'de> for AnimationNodeLoadDeserializer<'_, '_> {
                         deserialize_handle(registration, deserializer, load_context)
                     }),
                 };
-                let reflect_deserializer = TypedReflectDeserializer::new_with_processor(
+                let reflect_deserializer = TypedReflectDeserializer::with_processor(
                     type_registration,
                     type_registry,
                     &mut processor,

crates/bevy_animation_graph/src/core/animation_graph/serial.rs

@@ -0,0 +1,49 @@
+use bevy::reflect::{ArrayInfo, DynamicArray, TypeRegistry};
+use core::{fmt, fmt::Formatter};
+use serde::de::{Error, SeqAccess, Visitor};
+
+use super::{
+    registration_utils::try_get_registration, ReflectDeserializerProcessor,
+    TypedReflectDeserializer,
+};
+
+/// A [`Visitor`] for deserializing [`Array`] values.
+///
+/// [`Array`]: crate::Array
+pub(super) struct ArrayVisitor<'a, P> {
+    pub array_info: &'static ArrayInfo,
+    pub registry: &'a TypeRegistry,
+    pub processor: Option<&'a mut P>,
+}
+
+impl<'de, P: ReflectDeserializerProcessor> Visitor<'de> for ArrayVisitor<'_, P> {
+    type Value = DynamicArray;
+
+    fn expecting(&self, formatter: &mut Formatter) -> fmt::Result {
+        formatter.write_str("reflected array value")
+    }
+
+    fn visit_seq<V>(mut self, mut seq: V) -> Result<Self::Value, V::Error>
+    where
+        V: SeqAccess<'de>,
+    {
+        let mut vec = Vec::with_capacity(seq.size_hint().unwrap_or_default());
+        let registration = try_get_registration(self.array_info.item_ty(), self.registry)?;
+        while let Some(value) = seq.next_element_seed(TypedReflectDeserializer::new_internal(
+            registration,
+            self.registry,
+            self.processor.as_deref_mut(),
+        ))? {
+            vec.push(value);
+        }
+
+        if vec.len() != self.array_info.capacity() {
+            return Err(Error::invalid_length(
+                vec.len(),
+                &self.array_info.capacity().to_string().as_str(),
+            ));
+        }
+
+        Ok(DynamicArray::new(vec.into_boxed_slice()))
+    }
+}

crates/bevy_animation_graph/src/utils/de/arrays.rs

@@ -0,0 +1,84 @@
+use bevy::reflect::{erased_serde, FromType, PartialReflect, TypeRegistry};
+use serde::Deserializer;
+
+use super::error_utils::make_custom_error;
+
+/// Trait used to provide finer control when deserializing a reflected type with one of
+/// the reflection deserializers.
+///
+/// This trait is the reflection equivalent of `serde`'s [`Deserialize`] trait.
+/// The main difference is that this trait provides access to the [`TypeRegistry`],
+/// which means that we can use the registry and all its stored type information
+/// to deserialize our type.
+///
+/// This can be useful when writing a custom reflection deserializer where we may
+/// want to handle parts of the deserialization process, but temporarily pass control
+/// to the standard reflection deserializer for other parts.
+///
+/// For the serialization equivalent of this trait, see [`SerializeWithRegistry`].
+///
+/// # Rationale
+///
+/// Without this trait and its associated [type data], such a deserializer would have to
+/// write out all of the deserialization logic itself, possibly including
+/// unnecessary code duplication and trivial implementations.
+///
+/// This is because a normal [`Deserialize`] implementation has no knowledge of the
+/// [`TypeRegistry`] and therefore cannot create a reflection-based deserializer for
+/// nested items.
+///
+/// # Implementors
+///
+/// In order for this to work with the reflection deserializers like [`TypedReflectDeserializer`]
+/// and [`ReflectDeserializer`], implementors should be sure to register the
+/// [`ReflectDeserializeWithRegistry`] type data.
+/// This can be done [via the registry] or by adding `#[reflect(DeserializeWithRegistry)]` to
+/// the type definition.
+///
+/// [`Deserialize`]: ::serde::Deserialize
+/// [`SerializeWithRegistry`]: crate::serde::SerializeWithRegistry
+/// [type data]: ReflectDeserializeWithRegistry
+/// [`TypedReflectDeserializer`]: crate::serde::TypedReflectDeserializer
+/// [`ReflectDeserializer`]: crate::serde::ReflectDeserializer
+/// [via the registry]: TypeRegistry::register_type_data
+pub trait DeserializeWithRegistry<'de>: PartialReflect + Sized {
+    fn deserialize<D>(deserializer: D, registry: &TypeRegistry) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>;
+}
+
+/// Type data used to deserialize a [`PartialReflect`] type with a custom [`DeserializeWithRegistry`] implementation.
+#[derive(Clone)]
+pub struct ReflectDeserializeWithRegistry {
+    deserialize: fn(
+        deserializer: &mut dyn erased_serde::Deserializer,
+        registry: &TypeRegistry,
+    ) -> Result<Box<dyn PartialReflect>, erased_serde::Error>,
+}
+
+impl ReflectDeserializeWithRegistry {
+    /// Deserialize a [`PartialReflect`] type with this type data's custom [`DeserializeWithRegistry`] implementation.
+    pub fn deserialize<'de, D>(
+        &self,
+        deserializer: D,
+        registry: &TypeRegistry,
+    ) -> Result<Box<dyn PartialReflect>, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let mut erased = <dyn erased_serde::Deserializer>::erase(deserializer);
+        (self.deserialize)(&mut erased, registry).map_err(make_custom_error)
+    }
+}
+
+impl<T: PartialReflect + for<'de> DeserializeWithRegistry<'de>> FromType<T>
+    for ReflectDeserializeWithRegistry
+{
+    fn from_type() -> Self {
+        Self {
+            deserialize: |deserializer, registry| {
+                Ok(Box::new(T::deserialize(deserializer, registry)?))
+            },
+        }
+    }
+}