use std::rc::Rc;
use three_rs::addons::controls::OrbitControls;
use three_rs::testing::DeterministicRandom;
use three_rs::utils::date_now_ms;
use three_rs::{
sphere_geometry, Color, CubeTextureLoader, Mesh, MeshBasicNodeMaterial, PerspectiveCamera,
Renderer, RendererParameters, Scene, Vector3,
};
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: Scene,
pub camera: PerspectiveCamera,
}
fn examples_dir() -> std::path::PathBuf {
let three = three_rs::testing::three_js_dir();
three.join("examples")
}
pub fn init() -> App {
let camera = PerspectiveCamera::new(60.0, INNER_WIDTH / INNER_HEIGHT, 0.01, 100.0);
camera.node.borrow_mut().position.z = 3.0;
let path = examples_dir().join("textures/cube/pisa");
let format = "png";
let urls = [
path.join(format!("px.{format}")),
path.join(format!("nx.{format}")),
path.join(format!("py.{format}")),
path.join(format!("ny.{format}")),
path.join(format!("pz.{format}")),
path.join(format!("nz.{format}")),
];
let texture_cube = CubeTextureLoader::new().load(urls).unwrap();
let mut scene = Scene::new();
scene.set_background(texture_cube.clone());
let geometry = Rc::new(sphere_geometry(0.1, 32, 16));
let mut material = MeshBasicNodeMaterial::new();
material.color = Color::from_hex(0xffffff);
material.env_map = Some(texture_cube);
let mut random = DeterministicRandom::new();
for _ in 0..500 {
let mesh = Mesh::new(geometry.clone(), material.clone());
{
let mut object = mesh.borrow_mut();
object.position.x = random.next() * 10.0 - 5.0;
object.position.y = random.next() * 10.0 - 5.0;
object.position.z = random.next() * 10.0 - 5.0;
let scale = random.next() * 3.0 + 1.0;
object.scale.set(scale, scale, scale);
}
scene.add(&mesh);
}
let mut renderer = Renderer::new(RendererParameters::default()).unwrap();
renderer.set_pixel_ratio(DPR);
renderer.set_size(INNER_WIDTH, INNER_HEIGHT);
App {
renderer,
scene,
camera,
}
}
pub fn animate(app: &mut App) {
let timer = 0.0001 * date_now_ms();
{
let mut camera_object = app.camera.node.borrow_mut();
let position = &mut camera_object.position;
position.x += (0.0 - position.x) * 0.05;
position.y += (0.0 - position.y) * 0.05;
}
app.camera.look_at(&Vector3::ZERO);
for (i, sphere) in app.scene.children().iter().enumerate() {
let mut sphere = sphere.borrow_mut();
sphere.position.x = 5.0 * (timer + i as f64).cos();
sphere.position.y = 5.0 * (timer + i as f64 * 1.1).sin();
}
app.renderer.render(&mut app.scene, &mut app.camera);
}
pub fn resize(app: &mut App, width: f64, height: f64) {
app.camera.aspect = width / height;
app.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_materials_basic.png".to_string());
three_rs::testing::write_png(&path, width, height, &pixels);
println!("wrote {path} ({width}x{height})");
}