#[path = "../helpers/camera_controller.rs"]
mod camera_controller;
use bevy::{pbr::ShadowFilteringMethod, prelude::*};
use camera_controller::{CameraController, CameraControllerPlugin};
fn main() {
App::new()
.add_plugins(DefaultPlugins)
.add_plugins(CameraControllerPlugin)
.add_systems(Startup, setup)
.add_systems(
Update,
(
cycle_filter_methods,
adjust_light_position,
adjust_point_light_biases,
toggle_light,
adjust_directional_light_biases,
),
)
.run();
}
#[derive(Component)]
struct Lights;
fn setup(
mut commands: Commands,
mut meshes: ResMut<Assets<Mesh>>,
mut materials: ResMut<Assets<StandardMaterial>>,
) {
let spawn_plane_depth = 300.0f32;
let spawn_height = 2.0;
let sphere_radius = 0.25;
let white_handle = materials.add(StandardMaterial {
base_color: Color::WHITE,
perceptual_roughness: 1.0,
..default()
});
let sphere_handle = meshes.add(Sphere::new(sphere_radius));
let light_transform = Transform::from_xyz(5.0, 5.0, 0.0).looking_at(Vec3::ZERO, Vec3::Y);
commands
.spawn((light_transform, Visibility::default(), Lights))
.with_children(|builder| {
builder.spawn(PointLight {
intensity: 0.0,
range: spawn_plane_depth,
color: Color::WHITE,
shadow_depth_bias: 0.0,
shadow_normal_bias: 0.0,
shadows_enabled: true,
..default()
});
builder.spawn(DirectionalLight {
shadow_depth_bias: 0.0,
shadow_normal_bias: 0.0,
shadows_enabled: true,
..default()
});
});
commands.spawn((
Camera3d::default(),
Transform::from_xyz(-1.0, 1.0, 1.0).looking_at(Vec3::new(-1.0, 1.0, 0.0), Vec3::Y),
CameraController::default(),
ShadowFilteringMethod::Hardware2x2,
));
for z_i32 in (-spawn_plane_depth as i32..=0).step_by(2) {
commands.spawn((
Mesh3d(sphere_handle.clone()),
MeshMaterial3d(white_handle.clone()),
Transform::from_xyz(
0.0,
if z_i32 % 4 == 0 {
spawn_height
} else {
sphere_radius
},
z_i32 as f32,
),
));
}
let plane_size = 2.0 * spawn_plane_depth;
commands.spawn((
Mesh3d(meshes.add(Plane3d::default().mesh().size(plane_size, plane_size))),
MeshMaterial3d(white_handle),
));
commands
.spawn((
Node {
position_type: PositionType::Absolute,
padding: UiRect::all(Val::Px(5.0)),
..default()
},
BackgroundColor(Color::BLACK.with_alpha(0.75)),
GlobalZIndex(i32::MAX),
))
.with_children(|p| {
p.spawn(Text::default()).with_children(|p| {
p.spawn(TextSpan::new("Controls:\n"));
p.spawn(TextSpan::new("R / Z - reset biases to default / zero\n"));
p.spawn(TextSpan::new(
"L - switch between directional and point lights [",
));
p.spawn(TextSpan::new("DirectionalLight"));
p.spawn(TextSpan::new("]\n"));
p.spawn(TextSpan::new(
"F - switch directional light filter methods [",
));
p.spawn(TextSpan::new("Hardware2x2"));
p.spawn(TextSpan::new("]\n"));
p.spawn(TextSpan::new("1/2 - change point light depth bias ["));
p.spawn(TextSpan::new("0.00"));
p.spawn(TextSpan::new("]\n"));
p.spawn(TextSpan::new("3/4 - change point light normal bias ["));
p.spawn(TextSpan::new("0.0"));
p.spawn(TextSpan::new("]\n"));
p.spawn(TextSpan::new("5/6 - change direction light depth bias ["));
p.spawn(TextSpan::new("0.00"));
p.spawn(TextSpan::new("]\n"));
p.spawn(TextSpan::new(
"7/8 - change direction light normal bias [",
));
p.spawn(TextSpan::new("0.0"));
p.spawn(TextSpan::new("]\n"));
p.spawn(TextSpan::new(
"left/right/up/down/pgup/pgdown - adjust light position (looking at 0,0,0) [",
));
p.spawn(TextSpan(format!("{:.1},", light_transform.translation.x)));
p.spawn(TextSpan(format!(" {:.1},", light_transform.translation.y)));
p.spawn(TextSpan(format!(" {:.1}", light_transform.translation.z)));
p.spawn(TextSpan::new("]\n"));
});
});
}
fn toggle_light(
input: Res<ButtonInput<KeyCode>>,
mut point_lights: Query<&mut PointLight>,
mut directional_lights: Query<&mut DirectionalLight>,
example_text: Single<Entity, With<Text>>,
mut writer: TextUiWriter,
) {
if input.just_pressed(KeyCode::KeyL) {
for mut light in &mut point_lights {
light.intensity = if light.intensity == 0.0 {
*writer.text(*example_text, 4) = "PointLight".to_string();
100000000.0
} else {
0.0
};
}
for mut light in &mut directional_lights {
light.illuminance = if light.illuminance == 0.0 {
*writer.text(*example_text, 4) = "DirectionalLight".to_string();
100000.0
} else {
0.0
};
}
}
}
fn adjust_light_position(
input: Res<ButtonInput<KeyCode>>,
mut lights: Query<&mut Transform, With<Lights>>,
example_text: Single<Entity, With<Text>>,
mut writer: TextUiWriter,
) {
let mut offset = Vec3::ZERO;
if input.just_pressed(KeyCode::ArrowLeft) {
offset.x -= 1.0;
}
if input.just_pressed(KeyCode::ArrowRight) {
offset.x += 1.0;
}
if input.just_pressed(KeyCode::ArrowUp) {
offset.z -= 1.0;
}
if input.just_pressed(KeyCode::ArrowDown) {
offset.z += 1.0;
}
if input.just_pressed(KeyCode::PageDown) {
offset.y -= 1.0;
}
if input.just_pressed(KeyCode::PageUp) {
offset.y += 1.0;
}
if offset != Vec3::ZERO {
let example_text = *example_text;
for mut light in &mut lights {
light.translation += offset;
light.look_at(Vec3::ZERO, Vec3::Y);
*writer.text(example_text, 22) = format!("{:.1},", light.translation.x);
*writer.text(example_text, 23) = format!(" {:.1},", light.translation.y);
*writer.text(example_text, 24) = format!(" {:.1}", light.translation.z);
}
}
}
fn cycle_filter_methods(
input: Res<ButtonInput<KeyCode>>,
mut filter_methods: Query<&mut ShadowFilteringMethod>,
example_text: Single<Entity, With<Text>>,
mut writer: TextUiWriter,
) {
if input.just_pressed(KeyCode::KeyF) {
for mut filter_method in &mut filter_methods {
let filter_method_string;
*filter_method = match *filter_method {
ShadowFilteringMethod::Hardware2x2 => {
filter_method_string = "Gaussian".to_string();
ShadowFilteringMethod::Gaussian
}
ShadowFilteringMethod::Gaussian => {
filter_method_string = "Temporal".to_string();
ShadowFilteringMethod::Temporal
}
ShadowFilteringMethod::Temporal => {
filter_method_string = "Hardware2x2".to_string();
ShadowFilteringMethod::Hardware2x2
}
};
*writer.text(*example_text, 7) = filter_method_string;
}
}
}
fn adjust_point_light_biases(
input: Res<ButtonInput<KeyCode>>,
mut query: Query<&mut PointLight>,
example_text: Single<Entity, With<Text>>,
mut writer: TextUiWriter,
) {
let depth_bias_step_size = 0.01;
let normal_bias_step_size = 0.1;
for mut light in &mut query {
if input.just_pressed(KeyCode::Digit1) {
light.shadow_depth_bias -= depth_bias_step_size;
}
if input.just_pressed(KeyCode::Digit2) {
light.shadow_depth_bias += depth_bias_step_size;
}
if input.just_pressed(KeyCode::Digit3) {
light.shadow_normal_bias -= normal_bias_step_size;
}
if input.just_pressed(KeyCode::Digit4) {
light.shadow_normal_bias += normal_bias_step_size;
}
if input.just_pressed(KeyCode::KeyR) {
light.shadow_depth_bias = PointLight::DEFAULT_SHADOW_DEPTH_BIAS;
light.shadow_normal_bias = PointLight::DEFAULT_SHADOW_NORMAL_BIAS;
}
if input.just_pressed(KeyCode::KeyZ) {
light.shadow_depth_bias = 0.0;
light.shadow_normal_bias = 0.0;
}
*writer.text(*example_text, 10) = format!("{:.2}", light.shadow_depth_bias);
*writer.text(*example_text, 13) = format!("{:.1}", light.shadow_normal_bias);
}
}
fn adjust_directional_light_biases(
input: Res<ButtonInput<KeyCode>>,
mut query: Query<&mut DirectionalLight>,
example_text: Single<Entity, With<Text>>,
mut writer: TextUiWriter,
) {
let depth_bias_step_size = 0.01;
let normal_bias_step_size = 0.1;
for mut light in &mut query {
if input.just_pressed(KeyCode::Digit5) {
light.shadow_depth_bias -= depth_bias_step_size;
}
if input.just_pressed(KeyCode::Digit6) {
light.shadow_depth_bias += depth_bias_step_size;
}
if input.just_pressed(KeyCode::Digit7) {
light.shadow_normal_bias -= normal_bias_step_size;
}
if input.just_pressed(KeyCode::Digit8) {
light.shadow_normal_bias += normal_bias_step_size;
}
if input.just_pressed(KeyCode::KeyR) {
light.shadow_depth_bias = DirectionalLight::DEFAULT_SHADOW_DEPTH_BIAS;
light.shadow_normal_bias = DirectionalLight::DEFAULT_SHADOW_NORMAL_BIAS;
}
if input.just_pressed(KeyCode::KeyZ) {
light.shadow_depth_bias = 0.0;
light.shadow_normal_bias = 0.0;
}
*writer.text(*example_text, 16) = format!("{:.2}", light.shadow_depth_bias);
*writer.text(*example_text, 19) = format!("{:.1}", light.shadow_normal_bias);
}
}