bevy_assets_extensions 0.8.1

macro_rules! reflect_serde {
    ($ty:ty => $snake:ident) => {
        paste::paste! {
            use bevy::reflect::{serde::{TypedReflectSerializer, TypedReflectDeserializer}, TypeRegistry};
            use serde::{Serializer, Deserializer, de::DeserializeSeed};

            fn [<registry_ $snake>]() -> &'static TypeRegistry {
                use once_cell::sync::Lazy;
                static REG: Lazy<TypeRegistry> = Lazy::new(|| {
                    let mut reg = TypeRegistry::default();
                    reg.register::<$ty>();
                    reg
                });
                &REG
            }

            fn [<ser_reflect_ $snake>]<S>(
                value: &$ty,
                serializer: S
            ) -> Result<S::Ok, S::Error>
            where
                S: Serializer
            {
                let ser = TypedReflectSerializer::new(value, [<registry_ $snake>]());
                ser.serialize(serializer)
            }

            fn [<de_reflect_ $snake>]<'de, D>(
                deserializer: D
            ) -> Result<$ty, D::Error>
            where
                D: Deserializer<'de>
            {
                let registry = [<registry_ $snake>]();
                let registration = registry.get(std::any::TypeId::of::<$ty>()).unwrap();
                let reflect_deser = TypedReflectDeserializer::new(registration, registry);
                let deserialized = reflect_deser.deserialize(deserializer)?;
                let value: $ty = $ty::from_reflect(deserialized.as_ref()).unwrap();
                Ok(value)
            }
        }
    };
}

pub(crate) use reflect_serde;