use std::cell::RefCell;
use std::rc::Rc;
use three_rs::addons::controls::OrbitControls;
use three_rs::geometries::{box_geometry, cylinder_geometry, plane_geometry};
use three_rs::lights::PointLight;
use three_rs::nodes::display::{convert_to_texture, ssgi, traa, RttNode, SsgiNode, TraaNode};
use three_rs::nodes::mrt;
use three_rs::nodes::tsl::{
diffuse_color, normal_view, output_property, pack_normal_to_rgb, vec4_join,
};
use three_rs::nodes::velocity::velocity;
use three_rs::objects::Background;
use three_rs::textures::TextureType;
use three_rs::{
pass, AmbientLight, Color, Mesh, MeshBasicNodeMaterial, MeshPhysicalNodeMaterial, 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;
pub struct App {
pub renderer: Renderer,
pub scene: Rc<RefCell<Scene>>,
pub camera: Rc<RefCell<PerspectiveCamera>>,
pub controls: OrbitControls,
pub scene_pass: PassNode,
pub gi_pass: SsgiNode,
pub composite: RttNode,
pub traa_node: TraaNode,
pub render_pipeline: RenderPipeline,
}
fn physical(hex: u32) -> MeshPhysicalNodeMaterial {
MeshPhysicalNodeMaterial::physical(Color::from_hex(hex), 1.0, 0.0)
}
pub fn init() -> App {
let camera = PerspectiveCamera::new(40.0, INNER_WIDTH / INNER_HEIGHT, 0.1, 100.0);
camera.node.borrow_mut().position.set(0.0, 10.0, 30.0);
let camera = Rc::new(RefCell::new(camera));
let mut scene = Scene::new();
scene.background = Some(Background::Color(Color::from_hex(0xaaaaaa)));
let scene = Rc::new(RefCell::new(scene));
let mut renderer = Renderer::new(RendererParameters::default()).unwrap();
renderer.set_pixel_ratio(DPR);
renderer.set_size(INNER_WIDTH, INNER_HEIGHT);
renderer.shadow_map_enabled = true;
let mut controls = OrbitControls::new(&mut camera.borrow_mut());
controls.set_element_size(INNER_WIDTH, INNER_HEIGHT);
controls.target.set(0.0, 7.0, 0.0);
controls.enable_pan = true;
controls.min_distance = 1.0;
controls.max_distance = 100.0;
let _ = controls.update(&mut camera.borrow_mut(), None);
let scene_pass = pass(scene.clone(), camera.clone());
let mut scene_mrt = mrt(vec![
("output", output_property()),
("diffuseColor", diffuse_color()),
]);
scene_mrt.set_deferred("normal", || pack_normal_to_rgb(normal_view()));
scene_mrt.set("velocity", velocity());
scene_pass.set_mrt(scene_mrt);
for name in ["diffuseColor", "normal"] {
scene_pass
.texture_named(name)
.set_texture_type(TextureType::UnsignedByte);
}
let scene_pass_color = scene_pass.texture_node("output");
let scene_pass_diffuse = scene_pass.texture_node("diffuseColor");
let _ = scene_pass.texture_node("depth");
let _ = scene_pass.texture_node("normal");
let _ = scene_pass.texture_node("velocity");
let gi_pass = ssgi(
&scene_pass.texture(),
&scene_pass.depth_texture(),
&scene_pass.texture_named("normal"),
camera.clone(),
);
gi_pass.slice_count.set(vec![2.0]);
gi_pass.step_count.set(vec![8.0]);
let ao = gi_pass.ao_node();
let gi = gi_pass.gi_node();
let composite_pass = vec4_join(vec![
scene_pass_color
.xyz()
.mul(ao)
.add(scene_pass_diffuse.xyz().mul(gi)),
scene_pass_color.w(),
]);
let composite = convert_to_texture(composite_pass);
let traa_node = traa(
&composite.texture(),
&scene_pass.depth_texture(),
&scene_pass.texture_named("velocity"),
camera.clone(),
);
let mut render_pipeline = RenderPipeline::new();
traa_node.attach(&mut render_pipeline);
render_pipeline.output_node = Some(traa_node.node());
let wall_geometry = Rc::new(plane_geometry(1.0, 1.0, 1, 1));
let left_wall = Mesh::new(wall_geometry.clone(), physical(0xff0000));
{
let mut object = left_wall.borrow_mut();
object.scale.set(20.0, 15.0, 1.0);
object.set_rotation(0.0, std::f64::consts::PI * 0.5, 0.0);
object.position.set(-10.0, 7.5, 0.0);
object.receive_shadow = true;
}
scene.borrow().add(&left_wall);
let right_wall = Mesh::new(wall_geometry.clone(), physical(0x00ff00));
{
let mut object = right_wall.borrow_mut();
object.scale.set(20.0, 15.0, 1.0);
object.set_rotation(0.0, std::f64::consts::PI * -0.5, 0.0);
object.position.set(10.0, 7.5, 0.0);
object.receive_shadow = true;
}
scene.borrow().add(&right_wall);
let white_material = physical(0xffffff);
let floor = Mesh::new(wall_geometry.clone(), white_material.clone());
{
let mut object = floor.borrow_mut();
object.scale.set(20.0, 20.0, 1.0);
object.set_rotation(std::f64::consts::PI * -0.5, 0.0, 0.0);
object.receive_shadow = true;
}
scene.borrow().add(&floor);
let back_wall = Mesh::new(wall_geometry.clone(), white_material.clone());
{
let mut object = back_wall.borrow_mut();
object.scale.set(15.0, 20.0, 1.0);
object.set_rotation(0.0, 0.0, std::f64::consts::PI * -0.5);
object.position.set(0.0, 7.5, -10.0);
object.receive_shadow = true;
}
scene.borrow().add(&back_wall);
let ceiling = Mesh::new(wall_geometry, white_material.clone());
{
let mut object = ceiling.borrow_mut();
object.scale.set(20.0, 20.0, 1.0);
object.set_rotation(std::f64::consts::PI * 0.5, 0.0, 0.0);
object.position.set(0.0, 15.0, 0.0);
object.receive_shadow = true;
}
scene.borrow().add(&ceiling);
let tall_box = Mesh::new(
Rc::new(box_geometry(5.0, 7.0, 5.0, 1, 1, 1)),
white_material.clone(),
);
{
let mut object = tall_box.borrow_mut();
object.set_rotation(0.0, std::f64::consts::PI * 0.25, 0.0);
object.position.set(-3.0, 3.5, -2.0);
object.cast_shadow = true;
object.receive_shadow = true;
}
scene.borrow().add(&tall_box);
let short_box = Mesh::new(
Rc::new(box_geometry(4.0, 4.0, 4.0, 1, 1, 1)),
white_material,
);
{
let mut object = short_box.borrow_mut();
object.set_rotation(0.0, std::f64::consts::PI * -0.1, 0.0);
object.position.set(4.0, 2.0, 4.0);
object.cast_shadow = true;
object.receive_shadow = true;
}
scene.borrow().add(&short_box);
let light_source = Mesh::new(
Rc::new(cylinder_geometry(2.5, 2.5, 1.0, 64)),
MeshBasicNodeMaterial::new(),
);
light_source.borrow_mut().position.y = 15.0;
scene.borrow().add(&light_source);
let point_light = PointLight::new(Color::from_hex(0xffffff), 100.0, 100.0);
{
let mut object = point_light.borrow_mut();
object.position.set(0.0, 13.0, 0.0);
object.cast_shadow = true;
let shadow = object.light_mut().unwrap().shadow.as_mut().unwrap();
shadow.map_size.x = 1024.0;
shadow.map_size.y = 1024.0;
}
scene.borrow().add(&point_light);
scene
.borrow()
.add(&AmbientLight::new(Color::from_hex(0x0c0c0c), 1.0));
App {
renderer,
scene,
camera,
controls,
scene_pass,
gi_pass,
composite,
traa_node,
render_pipeline,
}
}
pub fn animate(app: &mut App) {
let _ = app.controls.update(&mut app.camera.borrow_mut(), None);
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);
app.controls.set_element_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_ssgi.png".to_string());
three_rs::testing::write_png(&path, width, height, &pixels);
println!("wrote {path} ({width}x{height})");
}