use std::cell::RefCell;
use std::rc::Rc;
use three_rs::addons::controls::OrbitControls;
use three_rs::geometries::{plane_geometry, sphere_geometry, torus_knot_geometry};
use three_rs::materials::Side;
use three_rs::nodes::display::{oit_pass, OitPassNode};
use three_rs::{
pass, Color, DirectionalLight, Group, HemisphereLight, Mesh, MeshStandardNodeMaterial,
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 Params {
pub oit: bool,
pub opacity: f64,
}
pub struct App {
pub renderer: Renderer,
pub scene: Rc<RefCell<Scene>>,
pub camera: Rc<RefCell<PerspectiveCamera>>,
pub controls: OrbitControls,
pub spheres: three_rs::ObjectRef,
pub transparent_meshes: Vec<three_rs::ObjectRef>,
pub params: Params,
pub scene_pass_oit: OitPassNode,
pub scene_pass: PassNode,
pub render_pipeline: RenderPipeline,
}
pub fn init() -> App {
let params = Params {
oit: true,
opacity: 0.5,
};
let camera = PerspectiveCamera::new(45.0, INNER_WIDTH / INNER_HEIGHT, 0.1, 100.0);
camera.node.borrow_mut().position.set(8.0, 4.0, 10.0);
let mut scene = Scene::new();
scene.set_background(Color::from_hex(0x202020));
let hemi_light =
HemisphereLight::new(Color::from_hex(0xffffff), Color::from_hex(0x444444), 1.5);
scene.add(&hemi_light);
let dir_light = DirectionalLight::new(Color::from_hex(0xffffff), 2.5);
dir_light.borrow_mut().position.set(4.0, 10.0, 6.0);
scene.add(&dir_light);
let torus_knot = Mesh::new(
Rc::new(torus_knot_geometry(1.0, 0.4, 128, 32, 2.0, 3.0)),
MeshStandardNodeMaterial::standard(Color::from_hex(0xffffff), 0.2, 0.0),
);
scene.add(&torus_knot);
let mut transparent_meshes = Vec::new();
let plane_geometry = Rc::new(plane_geometry(6.0, 6.0, 1, 1));
const PLANE_COLORS: [u32; 3] = [0xff4030, 0x30d060, 0x3070ff];
for (i, &color) in PLANE_COLORS.iter().enumerate() {
let mut material = MeshStandardNodeMaterial::standard(Color::from_hex(color), 0.5, 0.0);
material.transparent = true;
material.opacity = params.opacity;
material.side = Side::Double;
let plane = Mesh::new(plane_geometry.clone(), material);
{
let mut object = plane.borrow_mut();
let rotation = object.rotation;
object.set_rotation(
rotation.x,
(i as f64 / PLANE_COLORS.len() as f64) * std::f64::consts::PI,
rotation.z,
);
}
scene.add(&plane);
transparent_meshes.push(plane);
}
let spheres = Group::new();
let sphere_geometry = Rc::new(sphere_geometry(0.8, 32, 16));
const SPHERE_COLORS: [u32; 4] = [0xffc020, 0xd040d0, 0x40c0d0, 0xa0d040];
for (i, &color) in SPHERE_COLORS.iter().enumerate() {
let mut material = MeshStandardNodeMaterial::standard(Color::from_hex(color), 0.3, 0.0);
material.transparent = true;
material.opacity = params.opacity;
let sphere = Mesh::new(sphere_geometry.clone(), material);
let angle = (i as f64 / SPHERE_COLORS.len() as f64) * std::f64::consts::PI * 2.0;
sphere
.borrow_mut()
.position
.set(angle.cos() * 2.5, 0.0, angle.sin() * 2.5);
spheres.add(&sphere);
transparent_meshes.push(sphere);
}
scene.add(&spheres);
let mut renderer = Renderer::new(RendererParameters::default()).unwrap();
renderer.set_pixel_ratio(DPR);
renderer.set_size(INNER_WIDTH, INNER_HEIGHT);
let scene = Rc::new(RefCell::new(scene));
let camera = Rc::new(RefCell::new(camera));
let scene_pass_oit = oit_pass(scene.clone(), camera.clone());
let scene_pass = pass(scene.clone(), camera.clone());
let mut render_pipeline = RenderPipeline::new();
render_pipeline.output_node = Some(scene_pass_oit.node());
let mut controls = {
let mut camera = camera.borrow_mut();
OrbitControls::new(&mut camera)
};
controls.set_element_size(INNER_WIDTH, INNER_HEIGHT);
controls.auto_rotate = true;
controls.enable_damping = true;
controls.min_distance = 5.0;
controls.max_distance = 25.0;
App {
renderer,
scene,
camera,
controls,
spheres,
transparent_meshes,
params,
scene_pass_oit,
scene_pass,
render_pipeline,
}
}
pub fn set_oit(app: &mut App, value: bool) {
app.params.oit = value;
app.render_pipeline.output_node = Some(if value {
app.scene_pass_oit.node()
} else {
app.scene_pass.node()
});
}
pub fn set_opacity(app: &mut App, value: f64) {
app.params.opacity = value;
for mesh in &app.transparent_meshes {
if let Some(material) = mesh.borrow_mut().payload.material_mut() {
material.opacity = value;
}
}
}
pub fn animate(app: &mut App) {
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);
}
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_oit.png".to_string());
three_rs::testing::write_png(&path, width, height, &pixels);
println!("wrote {path} ({width}x{height})");
}