Apply CustomMaterial to SceneBundle

[Youdiie]

First I uploaded a glTF file and set scene with this.

fn spawn_gltf(
    mut commands: Commands,
    ass: Res<AssetServer>,
) {
    let my_gltf = ass.load("my.glb#Scene0");
    commands.spawn(SceneBundle {
        scene: my_gltf,
        ..Default::default()
    });
}

Now I changed the colors of all materials like this.

fn change_scene_materials(
    mut query: Query<&mut Handle<StandardMaterial>>,
    mut materials: ResMut<Assets<StandardMaterial>>,
) {
    for material in query.iter_mut() {
        let mut color_mat = materials.get_mut(&material).unwrap();
        color_mat.base_color = Color::BLUE;
    }
}

Now I want to make a function applying CustomMaterial with glsl codes(like this example shader_material_glsl) to SceneBundle.
Is it possible? Any comment would be helpful!

(I found this bevy shader example, but this showed applying CustomMaterial to MaterialMeshBundle not SceneBundle..)

[nicopap]

This question came up a few times recently in the bevy discord. This is finally the opportunity to write it down on a search-engine-enabled web page.

You need to:

1. Iterate over all entities in the loaded scene (here we will use SceneSpawner::iter_instance_entities)
2. Get all the entities with the Handle<StandardMaterial> component
3. Get the StandardMaterial for that handle
4. Convert it into your custom material
5. Add the custom material to the assets, keeping track of the handle
6. Add the handle back to the entity in question, making sure to not forget to remove the Handle<StandardMaterial>

We will create a system that does all those steps and call it customize_scene_materials.

We create a new marker component CustomizeMaterial, add this component to the entity with the SceneBundle, so that the system can pick them up. If you add it to your app schedule, materials should automatically be updated every time the scene is loaded.

#[derive(AsBindGroup, TypeUuid, Debug, Clone)]
#[uuid = "f690fdae-d598-45ab-8225-97e2a3f056e0"]
pub struct MyCustomMaterial {
    // …
}
impl<'a> From<&'a StandardMaterial> for MyCustomMaterial {
    fn from(value: &'a StandardMaterial) -> Self {
        todo!()
    }
}
#[derive(Component)]
struct CustomizeMaterial;

pub fn customize_scene_materials(
    unloaded_instances: Query<(Entity, &SceneInstance), With<CustomizeMaterial>>,
    handles: Query<(Entity, &Handle<StandardMaterial>)>,
    pbr_materials: Res<Assets<StandardMaterial>>,
    scene_manager: Res<SceneSpawner>,
    mut custom_materials: ResMut<Assets<MyCustomMaterial>>,
    mut cmds: Commands,
) {
    for (entity, instance, hooked) in unloaded_instances.iter() {
        if scene_manager.instance_is_ready(**instance) {
            cmds.entity(entity).remove::<CustomizeMaterial>();
        }
        // Iterate over all entities in scene (once it's loaded)
        let handles = handles.iter_many(scene_manager.iter_instance_entities(**instance));
        for (entity, material_handle) in handles {
            let Some(material) = pbr_materials.get(material_handle) else { continue; };
            let custom = custom_materials.add(material.into());
            cmds.entity(entity).insert(custom).remove::<Handle<StandardMaterial>>();
        }
    }
}

A disadvantage of this is that the conversion occurs every time the scene is loaded. This should change in the future with asset pre-processing.

You might benefit to adding customize_scene_materials to your schedule with the following run condition:

app.add_system(customize_scene_materials.run_if(any_with_component::<CustomizeMaterial>()))

Edit: Just modifying existing material

If you don't want to add a custom material, but just edit an existing one, it's a bit easier:

#[derive(Component)]
struct CustomizeMaterial;

pub fn customize_scene_materials(
    unloaded_instances: Query<(Entity, &SceneInstance), With<CustomizeMaterial>>,
    handles: Query<(Entity, &Handle<StandardMaterial>)>,
    mut pbr_materials: ResMut<Assets<StandardMaterial>>,
    scene_manager: Res<SceneSpawner>,
) {
    for (entity, instance, hooked) in unloaded_instances.iter() {
        if scene_manager.instance_is_ready(**instance) {
            cmds.entity(entity).remove::<CustomizeMaterial>();
        }
        // Iterate over all entities in scene (once it's loaded)
        let handles = handles.iter_many(scene_manager.iter_instance_entities(**instance));
        for (entity, material_handle) in handles {
            let Some(material) = pbr_materials.get_mut(material_handle) else { continue; };
            material.color = Color::RED;
        }
    }
}

Modify individual scene materials

Several instances of the same scene share the same materials, if you want to only modify materials in one scene and not the other, you need to replace the Handle<StandardMaterial>

// Access mutably the handle, change the system parameter
    mut handles: Query<(Entity, &mut Handle<StandardMaterial>)>,
// Replace the inner `for` loop by this. It clones the material,
// creates a new one and replaces the handle
// Iterate over all entities in scene (once it's loaded)
let mut handles = handles.iter_many_mut(scene_manager.iter_instance_entities(**instance));
while let Some((entity, mut material_handle)) = handles.fetch_next() {
    let Some(material) = pbr_materials.get(material_handle) else { continue; };
    let mut new_material = material.clone();
    new_material.color = Color::RED;

    *material_handle = pbr_materials.add(new_material);
}

[nicopap]

If you spawn directly a cube and add the material to it, as in the example, it does work right?

If you replace the line

            cmds.entity(entity).insert(custom).remove::<Handle<StandardMaterial>>();

with

            cmds.entity(entity).insert(dbg!(custom)).remove::<Handle<StandardMaterial>>();

does it print something?

[Youdiie]

Oh, I forgot adding CustomizeMaterial to the entity with the SceneBundle. Sorry for bothering you.
After adding it, wgpu error occured :(

2023-05-03T07:57:51.623581Z ERROR wgpu::backend::direct: Handling wgpu errors as fatal by default    
thread 'Compute Task Pool (0)' panicked at 'wgpu error: Validation Error

Caused by:
    In Device::create_render_pipeline
      note: label = `opaque_mesh_pipeline`
    error matching VERTEX shader requirements against the pipeline
    location[2] Float32x2 interpolated as Some(Perspective) with sampling Some(Center) is not provided by the previous stage outputs
    input is not provided by the earlier stage in the pipeline

', /Users/gim-yujin/.cargo/registry/src/github.com-1ecc6299db9ec823/wgpu-0.14.2/src/backend/direct.rs:2403:5
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
thread 'main' panicked at 'called `Option::unwrap()` on a `None` value', /Users/gim-yujin/.cargo/registry/src/github.com-1ecc6299db9ec823/bevy_tasks-0.9.1/src/task_pool.rs:273:45

Is this error caused by glsl code error?

[nicopap]

I don't know what causes this issue.

Try copying the example shaders from custom_material.frag and custom_material.vert and only change them one step at a time, so it's easier to know what causes the issue.

I can only give generic programming advice for debugging why the shader doesn't work, I don't have experience with glsl shaders.

[Youdiie]

Actually I already copied those custom_material.frag and custom_material.vert code..🥲 I try to find the way applying glsl.
Anyway, thanks for helping me!

[Youdiie]

It was a glsl code error! I changed glsl example code to wgsl example code, and compile error didn't occur! Now I need to study wgsl code 😂
Thank you very much🙏🙏