Meshes flicker when retrieving mutable reference from AssetServer before adding new mesh

[Affinator]

Bevy version

0.16

Relevant system information

2025-05-28T13:21:01.933062Z  INFO bevy_render::renderer: AdapterInfo { name: "NVIDIA RTX A2000 Laptop GPU", vendor: 4318, device: 9656, device_type: DiscreteGpu, driver: "NVIDIA", driver_info: "553.62", backend: Vulkan }
2025-05-28T13:21:02.086063Z  INFO bevy_render::batching::gpu_preprocessing: GPU preprocessing is fully supported on this device.

What you did

I upgraded from 0.15 to 0.16. This worked without flicker before.

What went wrong

I wrote a clustered terrain generator for a strategy game (WIP). The terrain can be changed during gameplay.
After a cluster has been updated, I retrieve the meshes of the adjacent terrain clusters to average the normals at the borders between the clusters.

Starting with 0.16 just retrieving the mesh (independent if I change the mesh or not) to modify it by
if let Some(other_mesh) = meshes.get_mut(other_mesh_handle) {[....]}
creates a flickering mesh. It looks like that another mesh is displayed for a single frame, before the correct mesh is displayed again.

Additional information

screencap.mp4

In this example I am not altering the adjacent meshes. I am just retrieving a mutable borrow from the AssetServer.
If I only retrieve an immutable borrow the flicker disappears.

[rparrett]

This is probably fixed by #19083

[Affinator]

Unfortunately this is not fixed by 0.16.1.

PS: I'll try to better reproduce this on Wednesday.

[Affinator]

OK,
this must be some kind of race condition.

I was able to reproduce the flicker on a simple example:

• I spawn three cubes in a setup_system and I try to let one of the outer cubes (left or right) flicker
• In a system in the Update schedule
  • I retrieve mutable references to the meshes left and right (and i read them just to make sure the compiler does not optimize away any dead code)
  • I update/overwrite the mesh in the middle (alternating between a cube and a capsule)
  • Note1: I do this each second but then several times in a row (if time.elapsed_secs() % 1.0 < 0.1 {), but I am not sure if this is 100% needed. I got the flicker reproduced this way.
  • Note2: I do need to force the AssetServer to remove the old middle mesh (meshes.remove(debug_resource.middle_mesh.id());) to see the flicker. In my main project I do not need to force_remove to see the flicker. So I assume this may not be needed on another machine.

Example video (only visible just at the beginning, look at the outer cubes):

reproduction.mp4

Example project:

use bevy::prelude::*;

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

#[derive(Resource)]
struct DebugResource {
    middle_entity: Entity,
    middle_mesh: Mesh3d,
    right_mesh: Mesh3d,
    left_mesh: Mesh3d,
    middle_mesh_is_currently_cube: bool
}

/// set up a simple 3D scene
fn setup(
    mut commands: Commands,
    mut meshes: ResMut<Assets<Mesh>>,
    mut materials: ResMut<Assets<StandardMaterial>>,
) {
    // circular base
    commands.spawn((
        Mesh3d(meshes.add(Circle::new(4.0))),
        MeshMaterial3d(materials.add(Color::WHITE)),
        Transform::from_rotation(Quat::from_rotation_x(-std::f32::consts::FRAC_PI_2)),
    ));

    // middle cube
    let middle_mesh = Mesh3d(meshes.add(Cuboid::new(1.0, 1.0, 1.0)));
    let middle_entity = commands.spawn((
        middle_mesh.clone(),
        MeshMaterial3d(materials.add(Color::srgb_u8(124, 144, 255))),
        Transform::from_xyz(0.0, 0.5, 0.0),
    )).id();

    // right cube
    let right_mesh = Mesh3d(meshes.add(Cuboid::new(1.0, 1.0, 1.0)));
    commands.spawn((
        right_mesh.clone(),
        MeshMaterial3d(materials.add(Color::srgb_u8(87, 175, 64))),
        Transform::from_xyz(1.5, 0.5, 0.0),
    ));

    // left cube
    let left_mesh = Mesh3d(meshes.add(Cuboid::new(1.0, 1.0, 1.0)));
    commands.spawn((
        left_mesh.clone(),
        MeshMaterial3d(materials.add(Color::srgb_u8(87, 175, 64))),
        Transform::from_xyz(-1.5, 0.5, 0.0),
    ));

    // light
    commands.spawn((
        PointLight {
            shadows_enabled: true,
            ..default()
        },
        Transform::from_xyz(4.0, 8.0, 4.0),
    ));

    // camera
    commands.spawn((
        Camera3d::default(),
        Transform::from_xyz(-2.5, 4.5, 9.0).looking_at(Vec3::ZERO, Vec3::Y),
    ));

    let debug_resource = DebugResource {
        middle_entity,
        middle_mesh,
        right_mesh,
        left_mesh,
        middle_mesh_is_currently_cube: true        
    };

    commands.insert_resource(debug_resource);
}

fn flicker(
    time: Res<Time>,
    mut debug_resource: ResMut<DebugResource>,
    mut meshes: ResMut<Assets<Mesh>>,
    mut commands: Commands
)
{
    if time.elapsed_secs() % 1.0 < 0.1 {
        // get mutable reference to the mesh we want to flicker (read it to force the compiler to not optimize it away)
        if let Some(right_mesh) = meshes.get_mut(debug_resource.right_mesh.id()) {
            println!("got mutable reference to right_mesh mesh: {}", right_mesh.get_vertex_size());
        }

        // get mutable reference to another mesh we want to flicker (to increase the chance of it happening, read it to force the compiler to not optimize it away)
        if let Some(left_mesh) = meshes.get_mut(debug_resource.left_mesh.id()) {
            println!("got mutable reference to left_mesh mesh: {}", left_mesh.get_vertex_size());
        }

        // update middle mesh
        let new_mesh = if debug_resource.middle_mesh_is_currently_cube {
            debug_resource.middle_mesh_is_currently_cube = false;
            Capsule3d::new(1.0, 2.0).mesh().build()
        }
        else {
            debug_resource.middle_mesh_is_currently_cube = true;
            Cuboid::new(1.0, 1.0, 1.0).mesh().build()
        };
        
        let mut middle_entity = commands.entity(debug_resource.middle_entity);
        let new_mesh3d = Mesh3d(meshes.add(new_mesh));        
        meshes.remove(debug_resource.middle_mesh.id()); // This is needed here to reproduce the flicker on my machine in this example. In my main project it flickers without manually removing the mesh from the AssetServer.
        middle_entity.insert(new_mesh3d.clone());
        debug_resource.middle_mesh = new_mesh3d;
        println!("updated/overwrote cube1 mesh");

    }
}