use std::cell::RefCell;
use std::rc::Rc;
use three_rs::addons::controls::OrbitControls;
use three_rs::materials::{Blending, MeshBasicNodeMaterial};
use three_rs::math::ColorSpace;
use three_rs::nodes::display::{after_image, AfterImageNode};
use three_rs::nodes::tsl::{
float, instanced_data_attribute, mod_float, texture, time, uniform_value, vec2_join, vec3_join,
vec4_join,
};
use three_rs::nodes::{NodeRef, Type};
use three_rs::testing::DeterministicRandom;
use three_rs::{
pass, Color, ObjectRef, PassNode, PerspectiveCamera, RenderPipeline, Renderer,
RendererParameters, Scene, Sprite, TextureLoader, Vector3,
};
pub const INNER_WIDTH: f64 = 800.0;
pub const INNER_HEIGHT: f64 = 500.0;
pub const DPR: f64 = 1.0;
pub const INSPECTOR_RANDOM_DRAWS: usize = 5;
const RADIUS: f64 = 600.0;
pub const COUNT: usize = 50000;
pub struct App {
pub renderer: Renderer,
pub scene: Rc<RefCell<Scene>>,
pub camera: Rc<RefCell<PerspectiveCamera>>,
pub particles: ObjectRef,
pub scene_pass: PassNode,
pub after_image_pass: AfterImageNode,
pub damp: NodeRef,
pub render_pipeline: RenderPipeline,
}
fn examples_dir() -> std::path::PathBuf {
three_rs::testing::three_js_dir().join("examples")
}
fn get_random_point_on_sphere(random: &mut DeterministicRandom, r: f64) -> Vector3 {
let angle = random.next() * std::f64::consts::PI * 2.0;
let u = random.next() * 2.0 - 1.0;
Vector3::new(
angle.cos() * (1.0 - u.powi(2)).sqrt() * r,
angle.sin() * (1.0 - u.powi(2)).sqrt() * r,
u * r,
)
}
pub fn init() -> App {
let mut random = DeterministicRandom::new();
let damp = uniform_value(Type::F32, vec![0.8]);
let mut renderer = Renderer::new(RendererParameters::default()).unwrap();
renderer.set_pixel_ratio(DPR);
renderer.set_size(INNER_WIDTH, INNER_HEIGHT);
random.skip(INSPECTOR_RANDOM_DRAWS);
let camera = PerspectiveCamera::new(60.0, INNER_WIDTH / INNER_HEIGHT, 1.0, 10000.0);
camera.node.borrow_mut().position.z = 1000.0;
let mut scene = Scene::new();
scene.set_background(Color::from_hex(0x000000));
let sprite = TextureLoader::new()
.load(examples_dir().join("textures/sprites/circle.png"))
.unwrap();
let mut color = Color::new(0.0, 0.0, 0.0);
let mut colors = Vec::with_capacity(COUNT * 3);
let mut vertices = Vec::with_capacity(COUNT * 3);
let mut time_offsets = Vec::with_capacity(COUNT);
for i in 0..COUNT {
let vertex = get_random_point_on_sphere(&mut random, RADIUS);
vertices.extend([vertex.x as f32, vertex.y as f32, vertex.z as f32]);
color.set_hsl(i as f64 / COUNT as f64, 0.7, 0.7, ColorSpace::Srgb);
colors.extend([color.r as f32, color.g as f32, color.b as f32]);
time_offsets.push((i as f64 / COUNT as f64) as f32);
}
let position_attribute = Rc::new(vertices);
let color_attribute = Rc::new(colors);
let time_attribute = Rc::new(time_offsets);
let mut material = MeshBasicNodeMaterial::sprite();
material.blending = Blending::Additive;
material.depth_write = false;
let local_time =
instanced_data_attribute(&time_attribute, 1, 0, Type::F32).add(time().mul(float(0.1)));
let mod_time = mod_float(local_time, float(1.0));
let acc_time = mod_time.mul(mod_time.clone());
let angle = acc_time.mul(float(40.0));
let pulse = vec2_join(vec![
angle.sin().mul(float(20.0)),
angle.cos().mul(float(20.0)),
]);
let pos = instanced_data_attribute(&position_attribute, 3, 0, Type::Vec3);
let animated = vec3_join(vec![
pos.x().mul(acc_time.clone()).add(pulse.x()),
pos.y().mul(acc_time.clone()).add(pulse.y()),
pos.z().mul(acc_time).mul(float(1.75)),
]);
let f_alpha = mod_time.one_minus().mul(float(2.0));
material.color_node = Some(texture(&sprite).mul(vec4_join(vec![
instanced_data_attribute(&color_attribute, 3, 0, Type::Vec3),
f_alpha,
])));
material.position_node = Some(animated);
material.scale_node = Some(float(2.0));
let particles = Sprite::new(material);
particles
.borrow_mut()
.payload
.sprite_mut()
.expect("a Sprite's payload is a sprite")
.count = COUNT;
scene.add(&particles);
let mut render_pipeline = RenderPipeline::new();
let scene = Rc::new(RefCell::new(scene));
let camera = Rc::new(RefCell::new(camera));
let scene_pass = pass(scene.clone(), camera.clone());
let after_image_pass = after_image(&scene_pass.texture(), damp.clone());
render_pipeline.output_node = Some(after_image_pass.node());
App {
renderer,
scene,
camera,
particles,
scene_pass,
after_image_pass,
damp,
render_pipeline,
}
}
pub fn animate(app: &mut App) {
let time = three_rs::utils::now_ms();
{
let mut particles = app.particles.borrow_mut();
let rotation = particles.rotation;
particles.set_rotation(rotation.x, rotation.y, time * 0.001);
}
app.after_image_pass.render(&mut app.renderer);
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_afterimage.png".to_string());
three_rs::testing::write_png(&path, width, height, &pixels);
println!("wrote {path} ({width}x{height})");
}