B0002

To keep Rust rules on references (either one mutable reference or any number of immutable references) on a resource, it is not possible to have more than one resource of a kind if one is mutable in the same system. This can happen between Res<T> and ResMut<T> for the same T, or between NonSend<T> and NonSendMut<T> for the same T.

Erroneous code example:

use bevy::prelude::*;

fn update_materials(
    mut material_updater: ResMut<Assets<StandardMaterial>>,
    current_materials: Res<Assets<StandardMaterial>>,
) {
    // ...
}

fn main() {
    App::new()
        .add_plugins(DefaultPlugins)
        .add_systems(Update, update_materials)
        .run();
}

This will panic, as it's not possible to have both a mutable and an immutable resource on Assets<StandardMaterial> at the same time.

As a mutable resource already provides access to the current resource value, so you can remove the immutable resource.

use bevy::prelude::*;

fn update_materials(
    mut material_updater: ResMut<Assets<StandardMaterial>>,
) {
    // ...
}

fn main() {
    App::new()
        .add_plugins(DefaultPlugins)
        .add_systems(Update, update_materials)
        .run();
}

Resources as Components

Under the hood, resources are components. The consequences of this are usually nothing more than an implementation detail, however, you may run into an issue where the following system throws an error:

# use bevy::prelude::*;
# #[derive(Resource)]
# struct MyResource;
fn system(all_entities: Query<EntityMut>, res: Res<MyResource>) {}

It's not possible to both query all entities and a resource when resources are stored on an entity. To fix this, you should either constrain the all_entities query (you usually don't need to query every single entity), or exclude MyResource with Without<MyResource> or Without<IsResource>. Here, IsResource, is a marker component on every single entity that holds a resource, so it's very convenient if you want to exclude resources.

Queries that might conflict with Res or ResMut include:

• Query<()>
• Query<Entity>
• Query<EntityMut>
• Query<EntityRef>
• Query<EntityMutExcept>
• Query<EntityRefExcept>
• Query<Option<&T>>

You can run into the same problem with non-send data:

# use bevy::prelude::*;
# #[derive(Resource)]
# struct MyNonSend;
fn system(all_entities: Query<EntityMut>, some_non_send: NonSend<MyNonSend>) {}

This can be fixed by adding a Without<MyNonSend> filter to the query.