Fix broken deserialization for inputs and InputMaps

RELEASES.md

@@ -31,6 +31,7 @@
 
 ### Bugs (0.15.1)
 
+- fixed the broken deserialization of inputs and `InputMap`s
 - `InputMap::get_pressed` and siblings now check if the action kind is buttonlike before checking if they are pressed or released, avoiding a debug-mode panic
 - `InputMap::merge` is now compatible with all input kinds, previously limited to buttons
 

macros/src/typetag.rs

@@ -38,7 +38,7 @@ pub(crate) fn expand_serde_typetag(input: &ItemImpl) -> syn::Result<TokenStream>
 
         impl<'de, #generics_params> #crate_path::typetag::RegisterTypeTag<'de, dyn #trait_path> for #self_ty #where_clause {
             fn register_typetag(
-                registry: &mut #crate_path::typetag::MapRegistry<dyn #trait_path>,
+                registry: &mut #crate_path::typetag::InfallibleMapRegistry<dyn #trait_path>,
             ) {
                 #crate_path::typetag::Registry::register(
                     registry,

src/input_map.rs

@@ -957,24 +957,17 @@ mod tests {
     use crate as leafwing_input_manager;
     use crate::prelude::*;
 
-    #[derive(
-        Actionlike,
-        Serialize,
-        Deserialize,
-        Clone,
-        Copy,
-        PartialEq,
-        Eq,
-        PartialOrd,
-        Ord,
-        Hash,
-        Debug,
-        Reflect,
-    )]
+    #[derive(Actionlike, Serialize, Deserialize, Clone, PartialEq, Eq, Hash, Debug, Reflect)]
     enum Action {
         Run,
         Jump,
         Hide,
+        #[actionlike(Axis)]
+        Axis,
+        #[actionlike(DualAxis)]
+        DualAxis,
+        #[actionlike(Axis)]
+        TripleAxis,
     }
 
     #[test]
@@ -1117,4 +1110,55 @@ mod tests {
         input_map.clear_gamepad();
         assert_eq!(input_map.gamepad(), None);
     }
+
+    #[cfg(feature = "keyboard")]
+    #[test]
+    fn input_map_serde() {
+        use bevy::prelude::{App, KeyCode};
+        use serde_test::{assert_tokens, Token};
+
+        let mut app = App::new();
+
+        // Add the plugin to register input deserializers
+        app.add_plugins(InputManagerPlugin::<Action>::default());
+
+        let input_map = InputMap::new([(Action::Hide, KeyCode::ControlLeft)]);
+        assert_tokens(
+            &input_map,
+            &[
+                Token::Struct {
+                    name: "InputMap",
+                    len: 5,
+                },
+                Token::Str("buttonlike_map"),
+                Token::Map { len: Some(1) },
+                Token::UnitVariant {
+                    name: "Action",
+                    variant: "Hide",
+                },
+                Token::Seq { len: Some(1) },
+                Token::Map { len: Some(1) },
+                Token::BorrowedStr("KeyCode"),
+                Token::UnitVariant {
+                    name: "KeyCode",
+                    variant: "ControlLeft",
+                },
+                Token::MapEnd,
+                Token::SeqEnd,
+                Token::MapEnd,
+                Token::Str("axislike_map"),
+                Token::Map { len: Some(0) },
+                Token::MapEnd,
+                Token::Str("dual_axislike_map"),
+                Token::Map { len: Some(0) },
+                Token::MapEnd,
+                Token::Str("triple_axislike_map"),
+                Token::Map { len: Some(0) },
+                Token::MapEnd,
+                Token::Str("associated_gamepad"),
+                Token::None,
+                Token::StructEnd,
+            ],
+        );
+    }
 }

src/input_processing/dual_axis/custom.rs

@@ -16,10 +16,10 @@ use dyn_hash::DynHash;
 use once_cell::sync::Lazy;
 use serde::{Deserialize, Deserializer, Serialize, Serializer};
 use serde_flexitos::ser::require_erased_serialize_impl;
-use serde_flexitos::{serialize_trait_object, MapRegistry, Registry};
+use serde_flexitos::{serialize_trait_object, Registry};
 
 use crate::input_processing::DualAxisProcessor;
-use crate::typetag::RegisterTypeTag;
+use crate::typetag::{InfallibleMapRegistry, RegisterTypeTag};
 
 /// A trait for creating custom processor that handles dual-axis input values,
 /// accepting a [`Vec2`] input and producing a [`Vec2`] output.
@@ -287,8 +287,8 @@ impl<'de> Deserialize<'de> for Box<dyn CustomDualAxisProcessor> {
 }
 
 /// Registry of deserializers for [`CustomDualAxisProcessor`]s.
-static mut PROCESSOR_REGISTRY: Lazy<RwLock<MapRegistry<dyn CustomDualAxisProcessor>>> =
-    Lazy::new(|| RwLock::new(MapRegistry::new("CustomDualAxisProcessor")));
+static mut PROCESSOR_REGISTRY: Lazy<RwLock<InfallibleMapRegistry<dyn CustomDualAxisProcessor>>> =
+    Lazy::new(|| RwLock::new(InfallibleMapRegistry::new("CustomDualAxisProcessor")));
 
 /// A trait for registering a specific [`CustomDualAxisProcessor`].
 pub trait RegisterDualAxisProcessorExt {

src/input_processing/single_axis/custom.rs

@@ -16,10 +16,10 @@ use dyn_hash::DynHash;
 use once_cell::sync::Lazy;
 use serde::{Deserialize, Deserializer, Serialize, Serializer};
 use serde_flexitos::ser::require_erased_serialize_impl;
-use serde_flexitos::{serialize_trait_object, MapRegistry, Registry};
+use serde_flexitos::{serialize_trait_object, Registry};
 
 use crate::input_processing::AxisProcessor;
-use crate::typetag::RegisterTypeTag;
+use crate::typetag::{InfallibleMapRegistry, RegisterTypeTag};
 
 /// A trait for creating custom processor that handles single-axis input values,
 /// accepting a `f32` input and producing a `f32` output.
@@ -286,8 +286,8 @@ impl<'de> Deserialize<'de> for Box<dyn CustomAxisProcessor> {
 }
 
 /// Registry of deserializers for [`CustomAxisProcessor`]s.
-static mut PROCESSOR_REGISTRY: Lazy<RwLock<MapRegistry<dyn CustomAxisProcessor>>> =
-    Lazy::new(|| RwLock::new(MapRegistry::new("CustomAxisProcessor")));
+static mut PROCESSOR_REGISTRY: Lazy<RwLock<InfallibleMapRegistry<dyn CustomAxisProcessor>>> =
+    Lazy::new(|| RwLock::new(InfallibleMapRegistry::new("CustomAxisProcessor")));
 
 /// A trait for registering a specific [`CustomAxisProcessor`].
 pub trait RegisterCustomAxisProcessorExt {

src/plugin.rs

@@ -201,33 +201,33 @@ impl<A: Actionlike + TypePath + bevy::reflect::GetTypeRegistration> Plugin
         #[cfg(feature = "mouse")]
         app.register_type::<AccumulatedMouseMovement>()
             .register_type::<AccumulatedMouseScroll>()
-            .register_user_input::<MouseMoveDirection>()
-            .register_user_input::<MouseMoveAxis>()
-            .register_user_input::<MouseMove>()
-            .register_user_input::<MouseScrollDirection>()
-            .register_user_input::<MouseScrollAxis>()
-            .register_user_input::<MouseScroll>();
+            .register_buttonlike_input::<MouseMoveDirection>()
+            .register_axislike_input::<MouseMoveAxis>()
+            .register_dual_axislike_input::<MouseMove>()
+            .register_buttonlike_input::<MouseScrollDirection>()
+            .register_axislike_input::<MouseScrollAxis>()
+            .register_dual_axislike_input::<MouseScroll>();
 
         #[cfg(feature = "keyboard")]
-        app.register_user_input::<KeyCode>()
-            .register_user_input::<ModifierKey>()
-            .register_user_input::<KeyboardVirtualAxis>()
-            .register_user_input::<KeyboardVirtualDPad>()
-            .register_user_input::<KeyboardVirtualDPad3D>();
+        app.register_buttonlike_input::<KeyCode>()
+            .register_buttonlike_input::<ModifierKey>()
+            .register_axislike_input::<KeyboardVirtualAxis>()
+            .register_dual_axislike_input::<KeyboardVirtualDPad>()
+            .register_triple_axislike_input::<KeyboardVirtualDPad3D>();
 
         #[cfg(feature = "gamepad")]
-        app.register_user_input::<GamepadControlDirection>()
-            .register_user_input::<GamepadControlAxis>()
-            .register_user_input::<GamepadStick>()
-            .register_user_input::<GamepadButtonType>()
-            .register_user_input::<GamepadVirtualAxis>()
-            .register_user_input::<GamepadVirtualDPad>();
+        app.register_buttonlike_input::<GamepadControlDirection>()
+            .register_axislike_input::<GamepadControlAxis>()
+            .register_dual_axislike_input::<GamepadStick>()
+            .register_buttonlike_input::<GamepadButtonType>()
+            .register_axislike_input::<GamepadVirtualAxis>()
+            .register_dual_axislike_input::<GamepadVirtualDPad>();
 
         // Chords
-        app.register_user_input::<ButtonlikeChord>()
-            .register_user_input::<AxislikeChord>()
-            .register_user_input::<DualAxislikeChord>()
-            .register_user_input::<TripleAxislikeChord>();
+        app.register_buttonlike_input::<ButtonlikeChord>()
+            .register_axislike_input::<AxislikeChord>()
+            .register_dual_axislike_input::<DualAxislikeChord>()
+            .register_triple_axislike_input::<TripleAxislikeChord>();
 
         // General-purpose reflection
         app.register_type::<ActionState<A>>()

src/typetag.rs

@@ -1,9 +1,55 @@
 //! Type tag registration for trait objects
 
-pub use serde_flexitos::{MapRegistry, Registry};
+use std::collections::BTreeMap;
+
+pub use serde_flexitos::Registry;
+use serde_flexitos::{DeserializeFn, GetError};
 
 /// A trait for registering type tags.
 pub trait RegisterTypeTag<'de, T: ?Sized> {
-    /// Registers the specified type tag into the [`MapRegistry`].
-    fn register_typetag(registry: &mut MapRegistry<T>);
+    /// Registers the specified type tag into the [`InfallibleMapRegistry`].
+    fn register_typetag(registry: &mut InfallibleMapRegistry<T>);
+}
+
+/// An infallible version of [`MapRegistry`](serde_flexitos::MapRegistry)
+/// that allows multiple registrations of deserializers.
+pub struct InfallibleMapRegistry<O: ?Sized, I = &'static str> {
+    deserialize_fns: BTreeMap<I, Option<DeserializeFn<O>>>,
+    trait_object_name: &'static str,
+}
+
+impl<O: ?Sized, I> InfallibleMapRegistry<O, I> {
+    /// Creates a new registry, using `trait_object_name` as the name of `O` for diagnostic purposes.
+    #[inline]
+    pub fn new(trait_object_name: &'static str) -> Self {
+        Self {
+            deserialize_fns: BTreeMap::new(),
+            trait_object_name,
+        }
+    }
+}
+
+impl<O: ?Sized, I: Ord> Registry for InfallibleMapRegistry<O, I> {
+    type Identifier = I;
+    type TraitObject = O;
+
+    #[inline]
+    fn register(&mut self, id: I, deserialize_fn: DeserializeFn<O>) {
+        self.deserialize_fns
+            .entry(id)
+            .or_insert_with(|| Some(deserialize_fn));
+    }
+
+    #[inline]
+    fn get_deserialize_fn(&self, id: I) -> Result<&DeserializeFn<O>, GetError<I>> {
+        match self.deserialize_fns.get(&id) {
+            Some(Some(deserialize_fn)) => Ok(deserialize_fn),
+            _ => Err(GetError::NotRegistered { id }),
+        }
+    }
+
+    #[inline]
+    fn get_trait_object_name(&self) -> &'static str {
+        self.trait_object_name
+    }
 }

src/user_input/chord.rs

@@ -104,7 +104,6 @@ impl ButtonlikeChord {
     }
 }
 
-#[serde_typetag]
 impl UserInput for ButtonlikeChord {
     /// [`ButtonlikeChord`] acts as a virtual button.
     #[inline]
@@ -126,6 +125,7 @@ impl UserInput for ButtonlikeChord {
     }
 }
 
+#[serde_typetag]
 impl Buttonlike for ButtonlikeChord {
     /// Checks if all the inner inputs within the chord are active simultaneously.
     #[must_use]
@@ -193,7 +193,6 @@ impl AxislikeChord {
     }
 }
 
-#[serde_typetag]
 impl UserInput for AxislikeChord {
     /// [`AxislikeChord`] acts as a virtual axis.
     #[inline]
@@ -208,6 +207,7 @@ impl UserInput for AxislikeChord {
     }
 }
 
+#[serde_typetag]
 impl Axislike for AxislikeChord {
     fn value(&self, input_store: &CentralInputStore, gamepad: Gamepad) -> f32 {
         if self.button.pressed(input_store, gamepad) {
@@ -248,7 +248,6 @@ impl DualAxislikeChord {
     }
 }
 
-#[serde_typetag]
 impl UserInput for DualAxislikeChord {
     /// [`DualAxislikeChord`] acts as a virtual dual-axis.
     #[inline]
@@ -263,6 +262,7 @@ impl UserInput for DualAxislikeChord {
     }
 }
 
+#[serde_typetag]
 impl DualAxislike for DualAxislikeChord {
     fn axis_pair(&self, input_store: &CentralInputStore, gamepad: Gamepad) -> Vec2 {
         if self.button.pressed(input_store, gamepad) {
@@ -309,7 +309,6 @@ impl TripleAxislikeChord {
     }
 }
 
-#[serde_typetag]
 impl UserInput for TripleAxislikeChord {
     /// [`TripleAxislikeChord`] acts as a virtual triple-axis.
     #[inline]
@@ -324,6 +323,7 @@ impl UserInput for TripleAxislikeChord {
     }
 }
 
+#[serde_typetag]
 impl TripleAxislike for TripleAxislikeChord {
     fn axis_triple(&self, input_store: &CentralInputStore, gamepad: Gamepad) -> Vec3 {
         if self.button.pressed(input_store, gamepad) {