clearcoat/

clearcoat.rs

//! Demonstrates the clearcoat PBR feature.
//!
//! Clearcoat is a separate material layer that represents a thin translucent
//! layer over a material. Examples include (from the Filament spec [1]) car paint,
//! soda cans, and lacquered wood.
//!
//! In glTF, clearcoat is supported via the `KHR_materials_clearcoat` [2]
//! extension. This extension is well supported by tools; in particular,
//! Blender's glTF exporter maps the clearcoat feature of its Principled BSDF
//! node to this extension, allowing it to appear in Bevy.
//!
//! This Bevy example is inspired by the corresponding three.js example [3].
//!
//! [1]: https://google.github.io/filament/Filament.md.html#materialsystem/clearcoatmodel
//!
//! [2]: https://github.com/KhronosGroup/glTF/blob/main/extensions/2.0/Khronos/KHR_materials_clearcoat/README.md
//!
//! [3]: https://threejs.org/examples/webgl_materials_physical_clearcoat.html

use std::f32::consts::PI;

use bevy::{
    camera::Hdr,
    color::palettes::css::{BLUE, GOLD, WHITE},
    core_pipeline::tonemapping::Tonemapping::AcesFitted,
    feathers::{theme::UiTheme, FeathersPlugins},
    image::ImageLoaderSettings,
    light::Skybox,
    math::vec3,
    prelude::*,
    ui_widgets::{radio_self_update, ValueChange},
};

use radio::{feathers_option_buttons, main_ui_node_scene, RadioButtonOptionValue};

#[path = "../helpers/radio.rs"]
mod radio;

#[path = "../helpers/theme.rs"]
mod theme;

/// The size of each sphere.
const SPHERE_SCALE: f32 = 0.9;

/// The speed at which the spheres rotate, in radians per second.
const SPHERE_ROTATION_SPEED: f32 = 0.8;

/// Which type of light we're using: a point light or a directional light.
#[derive(Clone, Copy, PartialEq, Resource, Default)]
enum LightMode {
    #[default]
    Point,
    Directional,
}

/// Tags the example spheres.
#[derive(Component)]
struct ExampleSphere;

/// Entry point.
pub fn main() {
    App::new()
        .init_resource::<LightMode>()
        .add_plugins(DefaultPlugins)
        .add_plugins(FeathersPlugins)
        .insert_resource(UiTheme(theme::basic_example_theme(Color::WHITE)))
        .add_systems(Startup, setup)
        .add_systems(Update, animate_light)
        .add_systems(Update, animate_spheres)
        .add_observer(handle_selection_change)
        .add_observer(radio_self_update)
        .run();
}

/// Initializes the scene.
fn setup(
    mut commands: Commands,
    mut meshes: ResMut<Assets<Mesh>>,
    mut materials: ResMut<Assets<StandardMaterial>>,
    asset_server: Res<AssetServer>,
    light_mode: Res<LightMode>,
) {
    let sphere = create_sphere_mesh(&mut meshes);
    spawn_car_paint_sphere(&mut commands, &mut materials, &asset_server, &sphere);
    spawn_coated_glass_bubble_sphere(&mut commands, &mut materials, &sphere);
    spawn_golf_ball(&mut commands, &asset_server);
    spawn_scratched_gold_ball(&mut commands, &mut materials, &asset_server, &sphere);

    spawn_light(&mut commands);
    spawn_camera(&mut commands, &asset_server);
    spawn_buttons(&mut commands, light_mode);
}

/// Generates a sphere.
fn create_sphere_mesh(meshes: &mut Assets<Mesh>) -> Handle<Mesh> {
    // We're going to use normal maps, so make sure we've generated tangents, or
    // else the normal maps won't show up.

    let mut sphere_mesh = Sphere::new(1.0).mesh().build();
    sphere_mesh
        .generate_tangents()
        .expect("Failed to generate tangents");
    meshes.add(sphere_mesh)
}

/// Spawn a regular object with a clearcoat layer. This looks like car paint.
fn spawn_car_paint_sphere(
    commands: &mut Commands,
    materials: &mut Assets<StandardMaterial>,
    asset_server: &AssetServer,
    sphere: &Handle<Mesh>,
) {
    commands
        .spawn((
            Mesh3d(sphere.clone()),
            MeshMaterial3d(
                materials.add(StandardMaterial {
                    clearcoat: 1.0,
                    clearcoat_perceptual_roughness: 0.1,
                    normal_map_texture: Some(
                        asset_server
                            .load_builder()
                            .with_settings(|settings: &mut ImageLoaderSettings| {
                                settings.is_srgb = false;
                            })
                            .load("textures/BlueNoise-Normal.png"),
                    ),
                    metallic: 0.9,
                    perceptual_roughness: 0.5,
                    base_color: BLUE.into(),
                    ..default()
                }),
            ),
            Transform::from_xyz(-1.0, 1.0, 0.0).with_scale(Vec3::splat(SPHERE_SCALE)),
        ))
        .insert(ExampleSphere);
}

/// Spawn a semitransparent object with a clearcoat layer.
fn spawn_coated_glass_bubble_sphere(
    commands: &mut Commands,
    materials: &mut Assets<StandardMaterial>,
    sphere: &Handle<Mesh>,
) {
    commands
        .spawn((
            Mesh3d(sphere.clone()),
            MeshMaterial3d(materials.add(StandardMaterial {
                clearcoat: 1.0,
                clearcoat_perceptual_roughness: 0.1,
                metallic: 0.5,
                perceptual_roughness: 0.1,
                base_color: Color::srgba(0.9, 0.9, 0.9, 0.3),
                alpha_mode: AlphaMode::Blend,
                ..default()
            })),
            Transform::from_xyz(-1.0, -1.0, 0.0).with_scale(Vec3::splat(SPHERE_SCALE)),
        ))
        .insert(ExampleSphere);
}

/// Spawns an object with both a clearcoat normal map (a scratched varnish) and
/// a main layer normal map (the golf ball pattern).
///
/// This object is in glTF format, using the `KHR_materials_clearcoat`
/// extension.
fn spawn_golf_ball(commands: &mut Commands, asset_server: &AssetServer) {
    commands.spawn((
        WorldAssetRoot(
            asset_server.load(GltfAssetLabel::Scene(0).from_asset("models/GolfBall/GolfBall.glb")),
        ),
        Transform::from_xyz(1.0, 1.0, 0.0).with_scale(Vec3::splat(SPHERE_SCALE)),
        ExampleSphere,
    ));
}

/// Spawns an object with only a clearcoat normal map (a scratch pattern) and no
/// main layer normal map.
fn spawn_scratched_gold_ball(
    commands: &mut Commands,
    materials: &mut Assets<StandardMaterial>,
    asset_server: &AssetServer,
    sphere: &Handle<Mesh>,
) {
    commands
        .spawn((
            Mesh3d(sphere.clone()),
            MeshMaterial3d(
                materials.add(StandardMaterial {
                    clearcoat: 1.0,
                    clearcoat_perceptual_roughness: 0.3,
                    clearcoat_normal_texture: Some(
                        asset_server
                            .load_builder()
                            .with_settings(|settings: &mut ImageLoaderSettings| {
                                settings.is_srgb = false;
                            })
                            .load("textures/ScratchedGold-Normal.png"),
                    ),
                    metallic: 0.9,
                    perceptual_roughness: 0.1,
                    base_color: GOLD.into(),
                    ..default()
                }),
            ),
            Transform::from_xyz(1.0, -1.0, 0.0).with_scale(Vec3::splat(SPHERE_SCALE)),
        ))
        .insert(ExampleSphere);
}

/// Spawns a light.
fn spawn_light(commands: &mut Commands) {
    commands.spawn(create_point_light());
}

/// Spawns a camera with associated skybox and environment map.
fn spawn_camera(commands: &mut Commands, asset_server: &AssetServer) {
    commands
        .spawn((
            Camera3d::default(),
            Hdr,
            Projection::Perspective(PerspectiveProjection {
                fov: 27.0 / 180.0 * PI,
                ..default()
            }),
            Transform::from_xyz(0.0, 0.0, 10.0),
            AcesFitted,
        ))
        .insert(Skybox {
            brightness: 5000.0,
            image: Some(asset_server.load("environment_maps/pisa_specular_rgb9e5_zstd.ktx2")),
            ..default()
        })
        .insert(EnvironmentMapLight {
            diffuse_map: asset_server.load("environment_maps/pisa_diffuse_rgb9e5_zstd.ktx2"),
            specular_map: asset_server.load("environment_maps/pisa_specular_rgb9e5_zstd.ktx2"),
            intensity: 2000.0,
            ..default()
        });
}

/// Moves the light around.
fn animate_light(
    mut lights: Query<&mut Transform, Or<(With<PointLight>, With<DirectionalLight>)>>,
    time: Res<Time>,
) {
    let now = time.elapsed_secs();
    for mut transform in lights.iter_mut() {
        transform.translation = vec3(
            ops::sin(now * 1.4),
            ops::cos(now * 1.0),
            ops::cos(now * 0.6),
        ) * vec3(3.0, 4.0, 3.0);
        transform.look_at(Vec3::ZERO, Vec3::Y);
    }
}

/// Rotates the spheres.
fn animate_spheres(mut spheres: Query<&mut Transform, With<ExampleSphere>>, time: Res<Time>) {
    let now = time.elapsed_secs();
    for mut transform in spheres.iter_mut() {
        transform.rotation = Quat::from_rotation_y(SPHERE_ROTATION_SPEED * now);
    }
}

/// Spawns buttons at the bottom of the screen which allow the user to
/// toggle occlusion culling on or off.
fn spawn_buttons(commands: &mut Commands, light_mode: Res<LightMode>) {
    commands.spawn_scene(bsn! {
        @main_ui_node_scene()
            Children [
            @feathers_option_buttons(
                "Toggle light type",
                &[
                    (LightMode::Directional, "Directional"),
                    (LightMode::Point, "Point"),
                ],
                if *light_mode == LightMode::Directional { 0 } else { 1 },
            )
        ]
    });
}

/// Updates the light mode when the user toggles a radio.
fn handle_selection_change(
    event: On<ValueChange<Entity>>,
    mut commands: Commands,
    mut light_query: Query<Entity, Or<(With<PointLight>, With<DirectionalLight>)>>,
    new_value_query: Query<&RadioButtonOptionValue<LightMode>>,
    mut light_mode: ResMut<LightMode>,
) {
    let Ok(RadioButtonOptionValue(selection)) = new_value_query.get(event.value) else {
        return;
    };

    *light_mode = *selection;
    for light in light_query.iter_mut() {
        match *light_mode {
            LightMode::Directional => {
                commands
                    .entity(light)
                    .remove::<PointLight>()
                    .insert(create_directional_light());
            }
            LightMode::Point => {
                commands
                    .entity(light)
                    .remove::<DirectionalLight>()
                    .insert(create_point_light());
            }
        }
    }
}

/// Creates or recreates the moving point light.
fn create_point_light() -> PointLight {
    PointLight {
        color: WHITE.into(),
        intensity: 100000.0,
        ..default()
    }
}

/// Creates or recreates the moving directional light.
fn create_directional_light() -> DirectionalLight {
    DirectionalLight {
        color: WHITE.into(),
        illuminance: 1000.0,
        ..default()
    }
}