Type 'bevy_utils::Instant' did not register ReflectSerialize

[dolto]

Hello, I'm studying by making it into a form that transforms while reading Bevy Example.
I wrote the code while looking at Scene Sample, but the following error occurs.

Type 'bevy_utils::Instant' did not register ReflectSerialize

Here's my code.

use std::{fs::File, io::Write, time::Duration};

use bevy::{prelude::*, tasks::IoTaskPool};
use rand::Rng;
fn main() {
    App::new()
        .add_plugins(DefaultPlugins)
        .register_type::<MyComponent>()
        .register_type::<MyResource>()
        .add_systems(Startup, setup)
        .add_systems(Update, (scene_controll, cuboid_controller))
        .run();
}

#[derive(Component, Reflect)]
#[reflect(Component)]
struct MyComponent {
    pub value: String,
    #[reflect(skip_serializing)]
    pub _time: Duration,
}
impl FromWorld for MyComponent {
    fn from_world(world: &mut World) -> Self {
        let time = world.resource::<Time>();
        MyComponent {
            value: "none value".to_string(),
            _time: time.elapsed(),
        }
    }
}

#[derive(Resource, Reflect, Default)]
#[reflect(Resource)]
struct MyResource {
    pub value: String,
}

const SCENE_FILE_PATH: &str = "scenes/load_scene_example.scn.ron";
fn setup(mut commands: Commands) {
    commands.spawn(Camera3dBundle {
        transform: Transform::from_xyz(0., 5., 10.).looking_at(Vec3::ZERO, Vec3::Y),
        ..default()
    });
}
fn scene_controll(
    mut commands: Commands,
    assets_server: Res<AssetServer>,
    keyboard: Res<ButtonInput<KeyCode>>,
    world: &World,
) {
    // Save Scene
    if keyboard.just_pressed(KeyCode::KeyS) {
        // let mut scene_world = World::new();
        // let type_registry = world.resource::<AppTypeRegistry>().clone();
        // scene_world.insert_resource(type_registry);

        // let scene = DynamicScene::from_world(&scene_world);

        let scene = DynamicScene::from_world(world);

        let type_registry = world.resource::<AppTypeRegistry>();
        let serialized_scene = scene.serialize_ron(type_registry).unwrap(); // this is a problem

        IoTaskPool::get()
            .spawn(async move {
                File::create(format!("assets/{SCENE_FILE_PATH}"))
                    .and_then(|mut file| file.write(serialized_scene.as_bytes()))
                    .expect("Error while writing secen to file!!!");
            })
            .detach();
    }

    // Load Scene
    if keyboard.just_pressed(KeyCode::KeyL) {
        commands.spawn(DynamicSceneBundle {
            scene: assets_server.load(SCENE_FILE_PATH),
            ..default()
        });
    }
}
fn cuboid_controller(
    mut commands: Commands,
    mut meshes: ResMut<Assets<Mesh>>,
    mut materials: ResMut<Assets<StandardMaterial>>,
    keyboard: Res<ButtonInput<KeyCode>>,
) {
    // Make Cuboid and MyComponent
    if keyboard.just_pressed(KeyCode::KeyN) {
        let mut random = rand::thread_rng();
        commands.spawn((
            PbrBundle {
                mesh: meshes.add(Cuboid::new(1., 1., 1.)),
                material: materials.add(Color::rgb_u8(
                    random.gen_range(0..255),
                    random.gen_range(0..255),
                    random.gen_range(0..255),
                )),
                transform: Transform::from_xyz(
                    random.gen_range(-4.0..4.),
                    random.gen_range(-4.0..4.),
                    random.gen_range(-4.0..4.),
                ),
                ..default()
            },
            MyComponent {
                value: "hello".to_string(),
                _time: Duration::default(),
            },
        ));
    }
}

The intent in the code is to press the keyboard N key several times to create a cube and save it.

However, aside from not loading properly, if you try to save, you will get an error in an unexpected place.

As far as I understand it

let type_registry = world.resource::<AppTypeRegistry>();
let serialized_scene = scene.serialize_ron(type_registry).unwrap();

The meaning of is to get the Registry Types that have been braked in the app, serialize the entities corresponding to those types, and store them in the form of a string.

RegistryTypes all have Reflect Trait as shown in the code, so this error doesn't make sense to me...

I tried to find out through Googling, but I couldn't find the correct answer.

Thank you for reading, and it would be great if you could give me an answer.

Have a great day

[MrGVSV]

It's not pretty and you lose information but the current solution is to filter out the problematic resources/components manually:

let scene = DynamicSceneBuilder::from_world(world)
    .deny_resource::<Time<Real>>()
    .deny::<CameraRenderGraph>()
    .deny::<Exposure>()
    .deny::<CameraMainTextureUsages>()
    .extract_entities(world.iter_entities().map(|entity| entity.id()))
    .extract_resources()
    .build();

Ideally, things like Exposure would be serializable (it's only wrapping an f32 after all), but for some reason it's marked as #[reflect_value], which requires Serialize. It should probably be marked as a normal #[reflect].

However, some types will never be serializable, such as Time<Real> since Instant is an opaque type and cannot be sensibly serialized. So ideally these types would be filtered out by DynamicScene and friends automatically.

[dolto]

Thank you for your response.

However, the following error occurs when the above code is used.

Type 'std::sync::Arc<bevy_asset::handle::StrongHandle>' did not register ReflectSerialize

So I wrote the following code to filter only the parts that I want to save.

        let scene = DynamicSceneBuilder::from_world(world)
            .deny_all()
            .deny_all_resources()
            .allow::<MyComponent>()
            .allow::<Handle<Mesh>>()
            .allow::<Handle<StandardMaterial>>()
            .allow::<Transform>()
            .allow::<GlobalTransform>()
            .allow::<Visibility>()
            .allow::<InheritedVisibility>()
            .allow::<ViewVisibility>()
            .allow_resource::<MyResource>()
            .extract_entities(world.iter_entities().map(|entity| entity.id()))
            .extract_resources()
            .build();

However, the same error occurred for that code.

What this error means is not to use StrongHandle.
So I erased the allow::<Handle<*>>() part.

Still, the same error occurred...

It is very difficult to find information about why this error occurred.

Obviously, I understand that the famous scene editing plug-in provides the ability to store the components of cubes or other models, so I don't think it's impossible for me to implement.

Is there anything else I need to know?

[MrGVSV]

Hm. Could you share the full code with all of your changes?

[dolto]

Sure! Here's the code.

use std::{fs::File, io::Write, time::Duration};

use bevy::{
    prelude::*,
    render::camera::{CameraMainTextureUsages, CameraRenderGraph, Exposure},
    tasks::IoTaskPool,
};
use rand::Rng;
fn main() {
    App::new()
        .add_plugins(DefaultPlugins)
        .register_type::<MyComponent>()
        .register_type::<MyResource>()
        .add_systems(Startup, setup)
        .add_systems(Update, (scene_controll, cuboid_controller))
        .run();
}

#[derive(Component, Reflect)]
#[reflect(Component)]
struct MyComponent {
    pub value: String,
    #[reflect(skip_serializing)]
    pub _time: Duration,
}
impl FromWorld for MyComponent {
    fn from_world(world: &mut World) -> Self {
        let time = world.resource::<Time>();
        MyComponent {
            value: "none value".to_string(),
            _time: time.elapsed(),
        }
    }
}

#[derive(Resource, Reflect, Default)]
#[reflect(Resource)]
struct MyResource {
    pub value: String,
}

const SCENE_FILE_PATH: &str = "scenes/load_scene_example.scn.ron";
fn setup(mut commands: Commands) {
    commands.spawn(Camera3dBundle {
        transform: Transform::from_xyz(0., 5., 10.).looking_at(Vec3::ZERO, Vec3::Y),
        ..default()
    });
}
fn scene_controll(
    mut commands: Commands,
    assets_server: Res<AssetServer>,
    keyboard: Res<ButtonInput<KeyCode>>,
    world: &World,
) {
    // Save Scene
    if keyboard.just_pressed(KeyCode::KeyS) {
        // let mut scene_world = World::new();
        // let type_registry = world.resource::<AppTypeRegistry>().clone();
        // scene_world.insert_resource(type_registry);

        // let scene = DynamicScene::from_world(&scene_world);

        // let scene = DynamicSceneBuilder::from_world(world)
        //     .deny_all()
        //     .deny_all_resources()
        //     .allow::<MyComponent>()
        //     .allow::<Transform>()
        //     .allow::<GlobalTransform>()
        //     .allow::<Visibility>()
        //     .allow::<InheritedVisibility>()
        //     .allow::<ViewVisibility>()
        //     .allow_resource::<MyResource>()
        //     .extract_entities(world.iter_entities().map(|entity| entity.id()))
        //     .extract_resources()
        //     .build();

        let scene = DynamicSceneBuilder::from_world(world)
            .deny_resource::<Time<Real>>()
            .deny::<CameraRenderGraph>()
            .deny::<Exposure>()
            .deny::<CameraMainTextureUsages>()
            .extract_entities(world.iter_entities().map(|entity| entity.id()))
            .extract_resources()
            .build();

        let type_registry = world.resource::<AppTypeRegistry>();
        let serialized_scene = scene.serialize_ron(type_registry).unwrap();

        IoTaskPool::get()
            .spawn(async move {
                File::create(format!("assets/{SCENE_FILE_PATH}"))
                    .and_then(|mut file| file.write(serialized_scene.as_bytes()))
                    .expect("Error while writing secen to file!!!");
            })
            .detach();
    }

    // Load Scene
    if keyboard.just_pressed(KeyCode::KeyL) {
        commands.spawn(DynamicSceneBundle {
            scene: assets_server.load(SCENE_FILE_PATH),
            ..default()
        });
    }
}
fn cuboid_controller(
    mut commands: Commands,
    mut meshes: ResMut<Assets<Mesh>>,
    mut materials: ResMut<Assets<StandardMaterial>>,
    keyboard: Res<ButtonInput<KeyCode>>,
) {
    // Make Cuboid and MyComponent
    if keyboard.just_pressed(KeyCode::KeyN) {
        let mut random = rand::thread_rng();
        commands.spawn((
            PbrBundle {
                mesh: meshes.add(Cuboid::new(1., 1., 1.)),
                material: materials.add(Color::rgb_u8(
                    random.gen_range(0..255),
                    random.gen_range(0..255),
                    random.gen_range(0..255),
                )),
                transform: Transform::from_xyz(
                    random.gen_range(-4.0..4.),
                    random.gen_range(-4.0..4.),
                    random.gen_range(-4.0..4.),
                ),
                ..default()
            },
            MyComponent {
                value: "hello".to_string(),
                _time: Duration::default(),
            },
        ));
    }
}

[MrGVSV]

Sorry for the delay. Here's how you can fix the error:

let scene = DynamicSceneBuilder::from_world(world)
    .deny_all()
    .deny_all_resources()
    .allow::<MyComponent>()
    // Remove these lines:
    // .allow::<Handle<Mesh>>()
    // .allow::<Handle<StandardMaterial>>()
    .allow::<Transform>()
    .allow::<GlobalTransform>()
    .allow::<Visibility>()
    .allow::<InheritedVisibility>()
    .allow::<ViewVisibility>()
    .allow_resource::<MyResource>()
    .extract_entities(world.iter_entities().map(|entity| entity.id()))
    .extract_resources()
    .build();

And note that the filtering can be somewhat simplified. Allowlists and denylists are mutually exclusive, so allowing a type implies all others not explicitly allowed are denied:

let scene = DynamicSceneBuilder::from_world(world)
    .allow::<MyComponent>()
    .allow::<Transform>()
    .allow::<GlobalTransform>()
    .allow::<Visibility>()
    .allow::<InheritedVisibility>()
    .allow::<ViewVisibility>()
    .allow_resource::<MyResource>()
    .extract_entities(world.iter_entities().map(|entity| entity.id()))
    .extract_resources()
    .build();

And for your particular case, you can also use a denylist:

let scene = DynamicSceneBuilder::from_world(world)
    .deny_resource::<Time<Real>>()
    .deny::<CameraRenderGraph>()
    .deny::<Exposure>()
    .deny::<CameraMainTextureUsages>()
    .deny::<Handle<Mesh>>()
    .deny::<Handle<StandardMaterial>>()
    .extract_entities(world.iter_entities().map(|entity| entity.id()))
    .extract_resources()
    .build();

Though I recommend allowlists to start with as it gives you the most control and better expectations of what will actually be included.