use std::cell::RefCell;
use std::rc::Rc;
use three_rs::addons::controls::OrbitControls;
use three_rs::animation::AnimationMixer;
use three_rs::loaders::{GltfLoader, UltraHdrLoader};
use three_rs::materials::{render_output, ToneMapping};
use three_rs::math::Vector3;
use three_rs::nodes::display::{
box_blur, convert_to_texture, fxaa, BoxBlurOptions, FxaaNode, RttNode,
};
use three_rs::nodes::node::SettableValue;
use three_rs::nodes::pmrem_node::PmremEnvironment;
use three_rs::nodes::tsl::{mix, smoothstep, uniform_settable, uniform_value};
use three_rs::nodes::{NodeRef, Type};
use three_rs::Timer;
use three_rs::{
pass, Color, PassNode, PerspectiveCamera, RenderPipeline, Renderer, RendererParameters, Scene,
};
pub const INNER_WIDTH: f64 = 800.0;
pub const INNER_HEIGHT: f64 = 500.0;
pub const DPR: f64 = 1.0;
fn examples_dir() -> std::path::PathBuf {
three_rs::testing::three_js_dir().join("examples")
}
pub struct App {
pub renderer: Renderer,
pub scene: Rc<RefCell<Scene>>,
pub camera: Rc<RefCell<PerspectiveCamera>>,
pub controls: OrbitControls,
pub mixer: AnimationMixer,
pub timer: Timer,
pub environment: PmremEnvironment,
pub focus_point: Vector3,
pub focus_point_view: SettableValue,
pub blur_size: NodeRef,
pub blur_spread: NodeRef,
pub min_distance: NodeRef,
pub max_distance: NodeRef,
pub scene_pass: PassNode,
pub fxaa_input: RttNode,
pub fxaa: FxaaNode,
pub render_pipeline: RenderPipeline,
}
pub fn init() -> App {
let mut camera = PerspectiveCamera::new(60.0, INNER_WIDTH / INNER_HEIGHT, 0.1, 100.0);
camera.node.borrow_mut().position.set(-6.0, 5.0, 6.0);
let mut controls = OrbitControls::new(&mut camera);
controls.set_element_size(INNER_WIDTH, INNER_HEIGHT);
controls.target.set(0.0, 2.0, 0.0);
controls.enable_damping = true;
controls.update(&mut camera, None);
let mut scene = Scene::new();
scene.set_background(Color::from_hex(0x90d5ff));
let timer = Timer::new();
let gltf = GltfLoader::load(examples_dir().join("models/gltf/bath_day.glb"))
.expect("three-rs: bath_day.glb loads");
let model = gltf.scene.clone();
scene.add(&model);
let mut mixer = AnimationMixer::new(Box::new(gltf.scene_resolver()));
let action = mixer.clip_action(&gltf.animations[0], None, None);
mixer.play(action);
let mut renderer = Renderer::new(RendererParameters::default()).unwrap();
renderer.set_pixel_ratio(DPR);
renderer.set_size(INNER_WIDTH, INNER_HEIGHT);
renderer.tone_mapping = ToneMapping::Neutral;
let env_map = UltraHdrLoader::new()
.load(examples_dir().join("textures/equirectangular/spruit_sunrise_2k.hdr.jpg"))
.unwrap();
scene.environment_rotation.y = std::f64::consts::PI * -0.5;
let mut environment = PmremEnvironment::from_equirectangular(&env_map);
environment.update(&mut renderer).unwrap();
scene.environment = Some(environment.handle());
let mut render_pipeline = RenderPipeline::new();
render_pipeline.output_color_transform = false;
let blur_size = uniform_value(Type::F32, vec![2.0]); let blur_spread = uniform_value(Type::F32, vec![4.0]); let min_distance = uniform_value(Type::F32, vec![1.0]); let max_distance = uniform_value(Type::F32, vec![3.0]);
let (focus_point_view_node, focus_point_view) =
uniform_settable(Type::Vec3, vec![0.0, 0.0, 0.0]);
let scene = Rc::new(RefCell::new(scene));
let camera = Rc::new(RefCell::new(camera));
let scene_pass = pass(scene.clone(), camera.clone());
let scene_pass_color = scene_pass.node();
let scene_pass_view_z = scene_pass.view_z_node("depth");
let mut blur_options = BoxBlurOptions::default();
blur_options.size = blur_size.clone();
blur_options.separation = blur_spread.clone();
let scene_pass_blurred = box_blur(&scene_pass.texture(), blur_options);
let blur = smoothstep(
min_distance.clone(),
max_distance.clone(),
scene_pass_view_z.sub(focus_point_view_node.z()).abs(),
);
let dof_pass = mix(scene_pass_color, scene_pass_blurred, blur);
let output_pass = render_output(dof_pass, renderer.tone_mapping);
let fxaa_input = convert_to_texture(output_pass);
let fxaa = fxaa(&fxaa_input.texture());
render_pipeline.output_node = Some(fxaa.node());
App {
renderer,
scene,
camera,
controls,
mixer,
timer,
environment,
focus_point: Vector3::new(1.0, 1.75, -0.4),
focus_point_view,
blur_size,
blur_spread,
min_distance,
max_distance,
scene_pass,
fxaa_input,
fxaa,
render_pipeline,
}
}
pub fn animate(app: &mut App) {
app.controls.update(&mut app.camera.borrow_mut(), None);
app.timer.update();
app.mixer.update(app.timer.get_delta());
{
let mut camera = app.camera.borrow_mut();
camera.update_matrix_world();
let mut view = app.focus_point;
view.apply_matrix4(&camera.matrix_world_inverse);
app.focus_point_view.set(vec![view.x, view.y, view.z]);
}
app.environment.update(&mut app.renderer).unwrap();
let (width, height) = app.renderer.drawing_buffer_size();
app.fxaa_input.set_size(width, height);
app.fxaa.update();
app.render_pipeline.render(&mut app.renderer);
}
pub fn resize(app: &mut App, width: f64, height: f64) {
let mut camera = app.camera.borrow_mut();
camera.aspect = width / height;
camera.update_projection_matrix();
app.renderer.set_size(width, height);
}
pub fn controls(app: &mut App) -> Option<&mut OrbitControls> {
Some(&mut app.controls)
}
pub fn controls_and_camera(
app: &mut App,
) -> Option<(&mut OrbitControls, std::cell::RefMut<'_, PerspectiveCamera>)> {
Some((&mut app.controls, app.camera.borrow_mut()))
}
fn main() {
three_rs::testing::pin_time(Some(0.0));
let mut app = init();
println!("adapter: {:?}", app.renderer.adapter_info());
animate(&mut app);
let (width, height, pixels) = app.renderer.read_canvas_pixels().unwrap();
let path = std::env::args()
.nth(1)
.unwrap_or_else(|| "target/webgpu_postprocessing_dof_basic.png".to_string());
three_rs::testing::write_png(&path, width, height, &pixels);
println!("wrote {path} ({width}x{height})");
}