Swapping out a ColorMaterial with another existing ColorMaterial from a small set?

[jackwayneright]

Hello! I feel like this should be fairly simple, but I seem to be struggling with it. My Bevy application is going to have just a few ColorMaterials in it. I want a system to be able to swap out which ColorMaterial a mesh is using.

So since I've only got a few ColorMaterials each of which I will use frequently and need easy access to, I thought I would put this into a resource using:

struct Palette {
    start: ColorMaterial,
    end: ColorMaterial,
}

impl Default for Palette {
    fn default() -> Palette {
        Palette {
            start: ColorMaterial::from(Color::BLUE),
            end: ColorMaterial::from(Color::RED),
        }
    }
}

// ...

App::new()
    // ...
    .init_resource::<Palette>()
    // ...

Then creating a mesh with the ColorMaterial:

commands.spawn(
    (
        MaterialMesh2dBundle {
            mesh: meshes.add(shape::Quad::new(Vec2 { x: 20., y: 30. }).into()).into(),
            material: palette.start,
            transform: Transform::from_translation(Vec3::new(0., 0., 0.)),
            ..default()
        },
        Thingy
    )
);

Then, when I want to swap out a ColorMaterial, I'd have a system do something like:

fn color_swap_system(
    mut query: Query<(&Thingy, With<Handle<ColorMaterial>>)>
) {
    for thingy in &mut query.iter() {
        thingy = Palette.end
    }
}

However, this doesn't work because the mesh expects a Handle<ColorMaterial>. I thought maybe I could have Palette store the Handles instead of the raw ColorMaterial, but so far the only way I've seen a Handle<ColorMaterial> created is through materials.add when materials is the resource passed to a Bevy system. This won't be available to my Palette::default.

All this said and not knowing much about Bevy, I don't know if storing my small set of color materials as a separate resource seems like a reasonable approach anyway, or if there are better options. Any thoughts or suggestions on how I should approach this? Thank you much!

[bravely-beep]

Rather than Default, implement FromWorld. init_resource always uses the FromWorld implementation — that trait just gets automatically implemented on anything that has Default.

[jackwayneright]

Update: It seems like cloneing or creating a new handle specifically set to the other handle's id is a reasonable solution to my below question.

Hello! Thank you for your time. After looking into FromWorld for a bit, if I'm understanding correctly, I should use the FromWorld as an alternative to Default to create my resource so it has access to other resources in the process. This way I can create my color material handles during the creation of my Palette. So I removed my Default and added:

impl FromWorld for Palette {
    fn from_world(world: &mut World) -> Self {
        let mut materials = world.get_resource_mut::<Assets<ColorMaterial>>().unwrap();
        Palette {
            start: materials.add(ColorMaterial::from(Color::BLUE)),
            end: materials.add(ColorMaterial::from(Color::RED)),
        }
    }
}

This gets me my color material handles in my palette resource. However, I still have issues then using these handles. For example,

commands.spawn(
    (
        MaterialMesh2dBundle {
            mesh: meshes.add(shape::Quad::new(Vec2 { x: 20., y: 30. }).into()).into(),
            material: palette.start,
            transform: Transform::from_translation(Vec3::new(0., 0., 0.)),
            ..default()
        },
        Thingy
    ));

ends up attempting to move the palette.start which is disallowed by the borrow checker. Is this what you expected I would do with FromWorld and I'm just still missing something about how to use the handles afterward? Would the intention be to just create clones of the handles? Or am I misunderstanding what you expected me to do with the FromWorld implementation? Thank you again for your time.