martian-chess/examples/shaders.rs

use bevy::pbr::ExtendedMaterial;
use bevy::pbr::MaterialExtension;
use bevy::pbr::MaterialMeshBundle;
use bevy::pbr::OpaqueRendererMethod;
use bevy::prelude::*;
use bevy::render::render_resource::*;

type MyMat = ExtendedMaterial<StandardMaterial, MatExt>;

fn main() {
    App::new()
        .add_plugins((
            DefaultPlugins.set(ImagePlugin::default_nearest()),
            MaterialPlugin::<MyMat>::default(),
        ))
        .add_systems(Startup, setup)
        .add_systems(Update, rotate)
        .add_systems(Update, setup_material)
        .run();
}

fn setup(mut commands: Commands, assets: Res<AssetServer>) {
    commands.spawn(SceneBundle {
        scene: assets.load("models/Martian Chess.glb#Scene0"),
        ..default()
    });

    commands.spawn(PointLightBundle {
        point_light: PointLight {
            intensity: 10.0,
            ..default()
        },
        transform: Transform::from_xyz(-1.0, 4.5, 4.0).looking_at(Vec3::ZERO, Vec3::Y),
        ..default()
    });

    commands.spawn(Camera3dBundle {
        transform: Transform::from_xyz(-1.0, 1.5, 4.0).looking_at(Vec3::ZERO, Vec3::Y),
        ..default()
    });
}

#[derive(Asset, AsBindGroup, Reflect, Debug, Clone)]
struct MatExt {
    #[uniform(100)]
    cutoff: f32,
}

impl MaterialExtension for MatExt {
    fn fragment_shader() -> ShaderRef {
        "examples/shaders/dissolve.wgsl".into()
    }
}

fn setup_material(
    events: Query<(Entity, &Handle<StandardMaterial>), Added<Handle<StandardMaterial>>>,
    standard_materials: Res<Assets<StandardMaterial>>,
    mut materials: ResMut<Assets<MyMat>>,
    mut commands: Commands,
) {
    events.iter().for_each(|(entity, handle)| {
        // Extension we will add to existing gltf-sourced materials
        let extension = MatExt { cutoff: 1.0 };
        // Base material we will extend for the duration of the dissolve effect
        let mut base = standard_materials
            .get(handle)
            .expect("Resolve material data")
            .clone();

        base.opaque_render_method = OpaqueRendererMethod::Auto;
        base.alpha_mode = AlphaMode::Mask(0.5);

        commands
            .entity(entity)
            .insert(materials.add(ExtendedMaterial { base, extension }))
            .remove::<Handle<StandardMaterial>>();
    })
}

fn rotate(
    mut query: Query<&mut Transform, With<Handle<Mesh>>>,
    time: Res<Time>,
    mut materials: ResMut<Assets<MyMat>>,
) {
    query.iter_mut().for_each(|mut t| {
        t.rotate_local_y(time.delta_seconds() / 2.0);
        // t.rotate_local_z(time.delta_seconds() / 2.0);
        // t.rotate_local_x(time.delta_seconds() / 2.0);
    });
    materials.iter_mut().for_each(|(_id, m)| {
        m.extension.cutoff = time.elapsed_seconds().sin().abs();
    })
}