use std::cell::RefCell;
use std::rc::Rc;
use three_rs::addons::controls::OrbitControls;
use three_rs::geometries::torus_geometry;
use three_rs::math::Color;
use three_rs::nodes::tsl::texture;
use three_rs::utils::now_ms;
use three_rs::{
box_geometry, pass, ColorSpace, Mesh, MinFilter, 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 camera: Rc<RefCell<PerspectiveCamera>>,
pub base_scene: Rc<RefCell<Scene>>,
pub mask_scene1: Rc<RefCell<Scene>>,
pub mask_scene2: Rc<RefCell<Scene>>,
pub boxed: three_rs::ObjectRef,
pub torus: three_rs::ObjectRef,
pub base: PassNode,
pub mask1: PassNode,
pub mask2: PassNode,
pub render_pipeline: RenderPipeline,
}
fn examples_dir() -> std::path::PathBuf {
let three = three_rs::testing::three_js_dir();
three.join("examples")
}
pub fn init() -> App {
let mut base_scene = Scene::new();
base_scene.set_background(Color::from_hex(0xe0e0e0));
let mask_scene1 = Scene::new();
let boxed = Mesh::new(Rc::new(box_geometry(4.0, 4.0, 4.0, 1, 1, 1)), None);
mask_scene1.add(&boxed);
let mask_scene2 = Scene::new();
let torus = Mesh::new(Rc::new(torus_geometry(3.0, 1.0, 16, 32)), None);
mask_scene2.add(&torus);
let camera = PerspectiveCamera::new(50.0, INNER_WIDTH / INNER_HEIGHT, 1.0, 1000.0);
camera.node.borrow_mut().position.z = 10.0;
let loader = three_rs::TextureLoader::new();
let texture1 = loader
.load(examples_dir().join("textures/758px-Canestra_di_frutta_(Caravaggio).jpg"))
.unwrap();
texture1.set_color_space(ColorSpace::Srgb);
texture1.set_min_filter(MinFilter::Linear);
texture1.set_generate_mipmaps(false);
texture1.set_flip_y(false);
let texture2 = loader
.load(examples_dir().join("textures/2294472375_24a3b8ef46_o.jpg"))
.unwrap();
texture2.set_color_space(ColorSpace::Srgb);
texture2.set_flip_y(false);
let mut renderer = Renderer::new(RendererParameters::default()).unwrap();
renderer.set_pixel_ratio(DPR);
renderer.set_size(INNER_WIDTH, INNER_HEIGHT);
let base_scene = Rc::new(RefCell::new(base_scene));
let mask_scene1 = Rc::new(RefCell::new(mask_scene1));
let mask_scene2 = Rc::new(RefCell::new(mask_scene2));
let camera = Rc::new(RefCell::new(camera));
let base = pass(base_scene.clone(), camera.clone());
let mask1 = pass(mask_scene1.clone(), camera.clone());
let mask2 = pass(mask_scene2.clone(), camera.clone());
let scene_mask1 = mask1.a();
let scene_mask2 = mask2.a();
let mut compose = base.node();
compose = scene_mask1.mix(compose, texture(&texture1));
compose = scene_mask2.mix(compose, texture(&texture2));
let mut render_pipeline = RenderPipeline::new();
render_pipeline.output_node = Some(compose);
App {
renderer,
camera,
base_scene,
mask_scene1,
mask_scene2,
boxed,
torus,
base,
mask1,
mask2,
render_pipeline,
}
}
pub fn animate(app: &mut App) {
let time: f64 = now_ms() * 0.001 + 6000.0;
{
let mut boxed = app.boxed.borrow_mut();
boxed.position.x = (time / 1.5).cos() * 2.0;
boxed.position.y = time.sin() * 2.0;
boxed.set_rotation(time, time / 2.0, 0.0);
}
{
let mut torus = app.torus.borrow_mut();
torus.position.x = time.cos() * 2.0;
torus.position.y = (time / 1.5).sin() * 2.0;
torus.set_rotation(time, time / 2.0, 0.0);
}
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> {
None
}
pub fn controls_and_camera(_app: &mut App) -> Option<(&mut OrbitControls, &mut PerspectiveCamera)> {
None
}
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_masking.png".to_string());
three_rs::testing::write_png(&path, width, height, &pixels);
println!("wrote {path} ({width}x{height})");
}