use std::cell::RefCell;
use std::rc::Rc;
use three_rs::addons::controls::OrbitControls;
use three_rs::loaders::GltfLoader;
use three_rs::materials::{render_output, ToneMapping};
use three_rs::nodes::display::{convert_to_texture, sobel, RttNode, SobelOperatorNode};
use three_rs::nodes::pmrem_node::PmremEnvironment;
use three_rs::{
pass, Color, MeshStandardNodeMaterial, PassNode, PerspectiveCamera, RenderPipeline, Renderer,
RendererParameters, RoomEnvironment, 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 scene_pass: PassNode,
pub sobel_input: RttNode,
pub sobel: SobelOperatorNode,
pub render_pipeline: RenderPipeline,
}
pub fn init() -> App {
let mut scene = Scene::new();
scene.set_background(Color::from_hex(0x000000));
let mut camera = PerspectiveCamera::new(70.0, INNER_WIDTH / INNER_HEIGHT, 0.1, 100.0);
camera.node.borrow_mut().position.set(0.0, 1.0, 3.0);
let gltf = GltfLoader::load(examples_dir().join("models/gltf/DragonAttenuation.glb"))
.expect("DragonAttenuation.glb");
let model = gltf.scene.children()[1].clone();
model
.borrow_mut()
.mesh_mut()
.expect("the dragon is a mesh")
.material = Some(MeshStandardNodeMaterial::standard(
Color::from_hex(0xffffff),
1.0,
0.0,
));
scene.add(&model);
let mut parameters = RendererParameters::default();
parameters.antialias = true;
let mut renderer = Renderer::new(parameters).unwrap();
renderer.set_pixel_ratio(DPR);
renderer.set_size(INNER_WIDTH, INNER_HEIGHT);
renderer.tone_mapping = ToneMapping::Linear;
let mut room = RoomEnvironment::new();
let environment = PmremEnvironment::from_scene(&mut renderer, &mut room, 0.04).unwrap();
scene.environment = Some(environment.handle());
let mut controls = OrbitControls::new(&mut camera);
controls.set_element_size(INNER_WIDTH, INNER_HEIGHT);
controls.enable_damping = true;
controls.enable_zoom = false;
controls.target.set(0.0, 0.5, 0.0);
controls.update(&mut camera, None);
let mut render_pipeline = RenderPipeline::new();
render_pipeline.output_color_transform = false;
let scene = Rc::new(RefCell::new(scene));
let camera = Rc::new(RefCell::new(camera));
let scene_pass = pass(scene.clone(), camera.clone());
let sobel_input = convert_to_texture(render_output(scene_pass.node(), renderer.tone_mapping));
let sobel = sobel(&sobel_input.texture());
render_pipeline.output_node = Some(sobel.node());
App {
renderer,
scene,
camera,
controls,
scene_pass,
sobel_input,
sobel,
render_pipeline,
}
}
pub fn animate(app: &mut App) {
app.controls.update(&mut app.camera.borrow_mut(), None);
let (width, height) = app.renderer.drawing_buffer_size();
app.sobel_input.set_size(width, height);
app.sobel.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_sobel.png".to_string());
three_rs::testing::write_png(&path, width, height, &pixels);
println!("wrote {path} ({width}x{height})");
}