Struct bevy::scene::serde::SceneSerializer

pub struct SceneSerializer<'a> {
    pub scene: &'a DynamicScene,
    pub registry: &'a TypeRegistryArc,
}

Handles serialization of a scene as a struct containing its entities and resources.

Examples

// Define an example component type.
#[derive(Component, Reflect, Default)]
#[reflect(Component)]
struct MyComponent {
    foo: [usize; 3],
    bar: (f32, f32),
    baz: String,
}

// Create our world, provide it with a type registry.
// Normally, [`App`] handles providing the type registry.
let mut world = World::new();
let registry = AppTypeRegistry::default();
{
    let mut registry = registry.write();
    // Register our component. Primitives and String are registered by default.
    // Sequence types are automatically handled.
    registry.register::<MyComponent>();
}
world.insert_resource(registry);
world.spawn(MyComponent {
    foo: [1, 2, 3],
    bar: (1.3, 3.7),
    baz: String::from("test"),
});

// Print out our serialized scene in the RON format.
let registry = world.resource::<AppTypeRegistry>();
let scene = DynamicScene::from_world(&world);
let scene_serializer = SceneSerializer::new(&scene, &registry.0);
println!("{}", bevy_scene::serialize_ron(scene_serializer).unwrap());

Fields

scene: &'a DynamicScene

The scene to serialize.

registry: &'a TypeRegistryArc

Type registry in which the components and resources types used in the scene are registered.

Implementations

impl<'a> SceneSerializer<'a>

pub fn new( scene: &'a DynamicScene, registry: &'a TypeRegistryArc ) -> SceneSerializer<'a>

Creates a scene serializer.

Trait Implementations

impl<'a> Serialize for SceneSerializer<'a>

fn serialize<S>( &self, serializer: S ) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.