use bevy::{
prelude::*,
reflect::{
serde::{ReflectSerializer, UntypedReflectDeserializer},
DynamicStruct,
},
};
use serde::de::DeserializeSeed;
fn main() {
App::new()
.add_plugins(DefaultPlugins)
.register_type::<Foo>()
.register_type::<Bar>()
.add_startup_system(setup)
.run();
}
#[derive(Reflect)]
pub struct Foo {
a: usize,
nested: Bar,
#[reflect(ignore)]
_ignored: NonReflectedValue,
}
#[derive(Reflect)]
pub struct Bar {
b: usize,
}
pub struct NonReflectedValue {
_a: usize,
}
fn setup(type_registry: Res<AppTypeRegistry>) {
let mut value = Foo {
a: 1,
_ignored: NonReflectedValue { _a: 10 },
nested: Bar { b: 8 },
};
*value.get_field_mut("a").unwrap() = 2usize;
assert_eq!(value.a, 2);
assert_eq!(*value.get_field::<usize>("a").unwrap(), 2);
let field = value.field("a").unwrap();
assert_eq!(*field.downcast_ref::<usize>().unwrap(), 2);
let mut patch = DynamicStruct::default();
patch.insert("a", 4usize);
value.apply(&patch);
assert_eq!(value.a, 4);
let type_registry = type_registry.read();
let serializer = ReflectSerializer::new(&value, &type_registry);
let ron_string =
ron::ser::to_string_pretty(&serializer, ron::ser::PrettyConfig::default()).unwrap();
info!("{}\n", ron_string);
let reflect_deserializer = UntypedReflectDeserializer::new(&type_registry);
let mut deserializer = ron::de::Deserializer::from_str(&ron_string).unwrap();
let reflect_value = reflect_deserializer.deserialize(&mut deserializer).unwrap();
let _deserialized_struct = reflect_value.downcast_ref::<DynamicStruct>();
assert!(reflect_value.reflect_partial_eq(&value).unwrap());
value.apply(&*reflect_value);
}