use std::sync::Arc;
use std::time::Instant;
use threers::cameras::Camera;
use threers::{
AmbientLight, BoxGeometry, Color, DirectionalLight, Euler,
Mesh, Object3D, PerspectiveCamera, Renderer, Scene,
StandardMaterial, Vector3,
};
use winit::{
event::{Event, WindowEvent},
event_loop::EventLoop,
window::WindowBuilder,
};
fn main() {
env_logger::init();
pollster::block_on(run());
}
async fn run() {
let event_loop = EventLoop::new().expect("event loop");
let window = Arc::new(
WindowBuilder::new()
.with_title("threers — spinning cube")
.with_inner_size(winit::dpi::LogicalSize::new(900, 700))
.build(&event_loop)
.expect("window"),
);
let instance = wgpu::Instance::new(wgpu::InstanceDescriptor {
backends: wgpu::Backends::PRIMARY,
..Default::default()
});
let surface = instance.create_surface(window.clone()).expect("surface");
let adapter = instance
.request_adapter(&wgpu::RequestAdapterOptions {
power_preference: wgpu::PowerPreference::default(),
compatible_surface: Some(&surface),
force_fallback_adapter: false,
})
.await
.expect("adapter");
let (device, queue) = adapter
.request_device(
&wgpu::DeviceDescriptor {
label: Some("threers device"),
required_features: wgpu::Features::empty(),
required_limits: wgpu::Limits::downlevel_defaults(),
},
None,
)
.await
.expect("device");
let device = Arc::new(device);
let queue = Arc::new(queue);
let size = window.inner_size();
let surface_caps = surface.get_capabilities(&adapter);
let format = surface_caps
.formats
.iter()
.copied()
.find(|f| f.is_srgb())
.unwrap_or(surface_caps.formats[0]);
let mut config = wgpu::SurfaceConfiguration {
usage: wgpu::TextureUsages::RENDER_ATTACHMENT,
format,
width: size.width.max(1),
height: size.height.max(1),
present_mode: surface_caps.present_modes[0],
alpha_mode: surface_caps.alpha_modes[0],
view_formats: vec![],
desired_maximum_frame_latency: 2,
};
surface.configure(&device, &config);
let mut renderer = Renderer::new(device.clone(), queue.clone(), format, config.width, config.height);
let mut scene = Scene::new();
scene.background = Color::from_hex(0x202030);
let geom = BoxGeometry::new(1.0, 1.0, 1.0);
let mat = StandardMaterial::new(Color::from_hex(0xff6633))
.with_roughness(0.4)
.with_metalness(0.1);
let cube_obj = Object3D::mesh(Mesh::new(geom, mat.into()));
let cube_id = scene.add(cube_obj);
scene.add_light(AmbientLight::new(Color::from_hex(0xffffff), 0.25));
let mut key = Object3D::light(
DirectionalLight::new(Color::from_hex(0xffffff), 1.0)
.with_direction(Vector3::new(-0.5, -1.0, -0.4)),
);
key.position = Vector3::new(3.0, 5.0, 2.0);
scene.add(key);
let mut camera = PerspectiveCamera::new(
60.0,
config.width as f32 / config.height as f32,
0.1,
100.0,
);
camera.position = Vector3::new(2.5, 2.0, 3.5);
camera.look_at(Vector3::ZERO);
let start = Instant::now();
let window_for_loop = window.clone();
event_loop
.run(move |event, target| {
match event {
Event::WindowEvent { event, window_id } if window_id == window_for_loop.id() => match event {
WindowEvent::CloseRequested => target.exit(),
WindowEvent::Resized(new_size) => {
config.width = new_size.width.max(1);
config.height = new_size.height.max(1);
surface.configure(&device, &config);
renderer.resize(config.width, config.height);
camera.set_aspect(config.width as f32 / config.height as f32);
}
WindowEvent::RedrawRequested => {
let t = start.elapsed().as_secs_f32();
if let Some(obj) = scene.get_mut(cube_id) {
obj.quaternion = Euler::new(t * 0.7, t * 1.1, 0.0).to_quaternion();
}
match surface.get_current_texture() {
Ok(frame) => {
let view = frame.texture.create_view(&wgpu::TextureViewDescriptor::default());
renderer.render(&mut scene, &camera, &view, false);
frame.present();
}
Err(wgpu::SurfaceError::Lost | wgpu::SurfaceError::Outdated) => {
surface.configure(&device, &config);
}
Err(e) => log::error!("surface error: {e:?}"),
}
window_for_loop.request_redraw();
}
_ => {}
},
_ => {}
}
})
.expect("event loop");
}