use std::sync::Arc;
use std::time::{Duration, Instant};
use three_rs::addons::controls::{
Key as OrbitKey, KeyEvent, MouseButton as OrbitButton, OrbitControls, PointerEvent, WheelDelta,
WheelEvent,
};
use three_rs::cameras::CameraMut;
use three_rs::Renderer;
use winit::application::ApplicationHandler;
use winit::event::{ElementState, MouseButton, MouseScrollDelta, WindowEvent};
use winit::event_loop::{ActiveEventLoop, ControlFlow, EventLoop};
use winit::keyboard::{Key, NamedKey};
use winit::window::{Window, WindowId};
macro_rules! example_name {
($module:ident) => {
stringify!($module)
};
($module:ident $name:literal) => {
$name
};
}
macro_rules! example_init {
($module:ident) => {
$module::init()
};
($module:ident await) => {
pollster::block_on($module::init())
};
}
macro_rules! examples {
( $( $variant:ident , $module:ident , $path:literal $( , $name:literal )? $( , $aw:ident )? ; )* ) => {
$(
#[path = $path]
#[allow(dead_code)] mod $module;
)*
#[derive(Clone, Copy, PartialEq, Eq, Debug)]
enum Which {
$( $variant, )*
}
#[allow(clippy::large_enum_variant)] enum Example {
$( $variant($module::App), )*
}
impl Which {
const ALL: [Which; [$( stringify!($variant) ),*].len()] = [
$( Self::$variant, )*
];
fn name(self) -> &'static str {
match self {
$( Self::$variant => example_name!($module $( $name )?), )*
}
}
}
impl Example {
fn build_raw(which: Which) -> Self {
match which {
$( Which::$variant => Example::$variant(example_init!($module $( $aw )?)), )*
}
}
fn renderer(&mut self) -> &mut Renderer {
match self {
$( Example::$variant(app) => &mut app.renderer, )*
}
}
fn animate(&mut self) {
match self {
$( Example::$variant(app) => $module::animate(app), )*
}
}
fn resize_example(&mut self, width: f64, height: f64) {
match self {
$( Example::$variant(app) => $module::resize(app, width, height), )*
}
}
fn controls(&mut self) -> Option<&mut OrbitControls> {
match self {
$( Example::$variant(app) => $module::controls(app), )*
}
}
fn controls_and_camera(
&mut self,
) -> Option<(&mut OrbitControls, CameraMut<'_>)> {
match self {
$( Example::$variant(app) => $module::controls_and_camera(app)
.map(|(controls, camera)| (controls, camera.into())), )*
}
}
}
};
}
examples! {
DepthTexture, webgpu_depth_texture, "../../examples/webgpu_depth_texture.rs";
InstanceMesh, webgpu_instance_mesh, "../../examples/webgpu_instance_mesh.rs";
MaterialsBasic, webgpu_materials_basic, "../../examples/webgpu_materials_basic.rs";
Rtt, webgpu_rtt, "../../examples/webgpu_rtt.rs";
LightsPhong, webgpu_lights_phong, "../../examples/webgpu_lights_phong.rs";
Morphtargets, webgpu_morphtargets, "../../examples/webgpu_morphtargets.rs";
Shadowmap, webgpu_shadowmap, "../../examples/webgpu_shadowmap.rs";
LightsPhysical, webgpu_lights_physical, "../../examples/webgpu_lights_physical.rs";
PostprocessingMasking, webgpu_postprocessing_masking, "../../examples/webgpu_postprocessing_masking.rs";
TslGalaxy, webgpu_tsl_galaxy, "../../examples/webgpu_tsl_galaxy.rs";
Skinning, webgpu_skinning, "../../examples/webgpu_skinning.rs";
MeshBatch, webgpu_mesh_batch, "../../examples/webgpu_mesh_batch.rs";
PostprocessingRadialBlur, webgpu_postprocessing_radial_blur, "../../examples/webgpu_postprocessing_radial_blur.rs";
Materials, webgpu_materials, "../../examples/webgpu_materials.rs";
PostprocessingSsaa, webgpu_postprocessing_ssaa, "../../examples/webgpu_postprocessing_ssaa.rs";
PmremCubemap, webgpu_pmrem_cubemap, "../../examples/webgpu_pmrem_cubemap.rs";
PostprocessingBloomSelective, webgpu_postprocessing_bloom_selective, "../../examples/webgpu_postprocessing_bloom_selective.rs";
ComputePoints, webgpu_compute_points, "../../examples/webgpu_compute_points.rs";
LinesFat, webgpu_lines_fat, "../../examples/webgpu_lines_fat.rs";
LinesFatRaycasting, webgpu_lines_fat_raycasting, "../../examples/webgpu_lines_fat_raycasting.rs";
PmremTest, webgpu_pmrem_test, "../../examples/webgpu_pmrem_test.rs";
PostprocessingDifference, webgpu_postprocessing_difference, "../../examples/webgpu_postprocessing_difference.rs";
PostprocessingDirect, webgpu_postprocessing_direct, "../../examples/webgpu_postprocessing_direct.rs";
FurnaceTest, webgpu_furnace_test, "../../examples/webgpu_furnace_test.rs";
PostprocessingAnamorphic, webgpu_postprocessing_anamorphic, "../../examples/webgpu_postprocessing_anamorphic.rs";
PmremScene, webgpu_pmrem_scene, "../../examples/webgpu_pmrem_scene.rs";
PostprocessingBloom, webgpu_postprocessing_bloom, "../../examples/webgpu_postprocessing_bloom.rs";
MaterialsEnvmaps, webgpu_materials_envmaps, "../../examples/webgpu_materials_envmaps.rs";
MaterialsCubemapMipmaps, webgpu_materials_cubemap_mipmaps, "../../examples/webgpu_materials_cubemap_mipmaps.rs";
PostprocessingBloomEmissive, webgpu_postprocessing_bloom_emissive, "../../examples/webgpu_postprocessing_bloom_emissive.rs";
InstanceUniform, webgpu_instance_uniform, "../../examples/webgpu_instance_uniform.rs";
TslInteroperability, webgpu_tsl_interoperability, "../../examples/webgpu_tsl_interoperability.rs";
PmremEquirectangular, webgpu_pmrem_equirectangular, "../../examples/webgpu_pmrem_equirectangular.rs";
PostprocessingCa, webgpu_postprocessing_ca, "../../examples/webgpu_postprocessing_ca.rs";
LoaderGltf, webgpu_loader_gltf, "../../examples/webgpu_loader_gltf.rs";
Mrt, webgpu_mrt, "../../examples/webgpu_mrt.rs";
CustomFogBackground, webgpu_custom_fog_background, "../../examples/webgpu_custom_fog_background.rs";
LoaderGltfSheen, webgpu_loader_gltf_sheen, "../../examples/webgpu_loader_gltf_sheen.rs";
Deferred, webgpu_deferred, "../../examples/webgpu_deferred.rs";
LoaderGltfAnisotropy, webgpu_loader_gltf_anisotropy, "../../examples/webgpu_loader_gltf_anisotropy.rs";
LoaderGltfTransmission, webgpu_loader_gltf_transmission, "../../examples/webgpu_loader_gltf_transmission.rs";
MaterialsTextureManualmipmap, webgpu_materials_texture_manualmipmap, "../../examples/webgpu_materials_texture_manualmipmap.rs";
TslVfxFlames, webgpu_tsl_vfx_flames, "../../examples/webgpu_tsl_vfx_flames.rs";
ProceduralTexture, webgpu_procedural_texture, "../../examples/webgpu_procedural_texture.rs";
PostprocessingSobel, webgpu_postprocessing_sobel, "../../examples/webgpu_postprocessing_sobel.rs";
PostprocessingFxaa, webgpu_postprocessing_fxaa, "../../examples/webgpu_postprocessing_fxaa.rs";
PostprocessingTransition, webgpu_postprocessing_transition, "../../examples/webgpu_postprocessing_transition.rs";
TslRagingSea, webgpu_tsl_raging_sea, "../../examples/webgpu_tsl_raging_sea.rs";
TslAngularSlicing, webgpu_tsl_angular_slicing, "../../examples/webgpu_tsl_angular_slicing.rs";
Textures2dArrayCompressed, webgpu_textures_2d_array_compressed, "../../examples/webgpu_textures_2d-array_compressed.rs", "webgpu_textures_2d-array_compressed";
ComputeTexture, webgpu_compute_texture, "../../examples/webgpu_compute_texture.rs";
VolumePerlin, webgpu_volume_perlin, "../../examples/webgpu_volume_perlin.rs";
ShadowmapVsm, webgpu_shadowmap_vsm, "../../examples/webgpu_shadowmap_vsm.rs";
ShadowmapPointlight, webgpu_shadowmap_pointlight, "../../examples/webgpu_shadowmap_pointlight.rs";
StructDrawindirect, webgpu_struct_drawindirect, "../../examples/webgpu_struct_drawindirect.rs";
Particles, webgpu_particles, "../../examples/webgpu_particles.rs";
Clearcoat, webgpu_clearcoat, "../../examples/webgpu_clearcoat.rs";
ModifierCurve, webgpu_modifier_curve, "../../examples/webgpu_modifier_curve.rs";
CameraArray, webgpu_camera_array, "../../examples/webgpu_camera_array.rs";
Sprites, webgpu_sprites, "../../examples/webgpu_sprites.rs";
InstanceSprites, webgpu_instance_sprites, "../../examples/webgpu_instance_sprites.rs";
MaterialsToon, webgpu_materials_toon, "../../examples/webgpu_materials_toon.rs";
Occlusion, webgpu_occlusion, "../../examples/webgpu_occlusion.rs";
FogHeight, webgpu_fog_height, "../../examples/webgpu_fog_height.rs";
ShadowmapOpacity, webgpu_shadowmap_opacity, "../../examples/webgpu_shadowmap_opacity.rs";
MultipleRendertargets, webgpu_multiple_rendertargets, "../../examples/webgpu_multiple_rendertargets.rs";
MultipleRendertargetsReadback, webgpu_multiple_rendertargets_readback, "../../examples/webgpu_multiple_rendertargets_readback.rs";
Texturegrad, webgpu_texturegrad, "../../examples/webgpu_texturegrad.rs";
Texturegather, webgpu_texturegather, "../../examples/webgpu_texturegather.rs";
LightsSelective, webgpu_lights_selective, "../../examples/webgpu_lights_selective.rs";
LoaderGltfCompressed, webgpu_loader_gltf_compressed, "../../examples/webgpu_loader_gltf_compressed.rs";
Equirectangular, webgpu_equirectangular, "../../examples/webgpu_equirectangular.rs";
SkinningPoints, webgpu_skinning_points, "../../examples/webgpu_skinning_points.rs";
InstancePoints, webgpu_instance_points, "../../examples/webgpu_instance_points.rs";
TexturesPartialupdate, webgpu_textures_partialupdate, "../../examples/webgpu_textures_partialupdate.rs";
Layers, webgpu_layers, "../../examples/webgpu_layers.rs";
LoaderGltfDiffuseRoughness, webgpu_loader_gltf_diffuse_roughness, "../../examples/webgpu_loader_gltf_diffuse_roughness.rs";
CubemapMix, webgpu_cubemap_mix, "../../examples/webgpu_cubemap_mix.rs";
Mirror, webgpu_mirror, "../../examples/webgpu_mirror.rs";
TslHalftone, webgpu_tsl_halftone, "../../examples/webgpu_tsl_halftone.rs";
TslEarth, webgpu_tsl_earth, "../../examples/webgpu_tsl_earth.rs";
Lightprobe, webgpu_lightprobe, "../../examples/webgpu_lightprobe.rs";
LightprobeCubecamera, webgpu_lightprobe_cubecamera, "../../examples/webgpu_lightprobe_cubecamera.rs", await;
Sky, webgpu_sky, "../../examples/webgpu_sky.rs";
Backdrop, webgpu_backdrop, "../../examples/webgpu_backdrop.rs";
PostprocessingMotionBlur, webgpu_postprocessing_motion_blur, "../../examples/webgpu_postprocessing_motion_blur.rs";
PostprocessingTraa, webgpu_postprocessing_traa, "../../examples/webgpu_postprocessing_traa.rs";
DisplayStereo, webgpu_display_stereo, "../../examples/webgpu_display_stereo.rs";
Ocean, webgpu_ocean, "../../examples/webgpu_ocean.rs";
Water, webgpu_water, "../../examples/webgpu_water.rs";
PostprocessingAo, webgpu_postprocessing_ao, "../../examples/webgpu_postprocessing_ao.rs";
PostprocessingGodrays, webgpu_postprocessing_godrays, "../../examples/webgpu_postprocessing_godrays.rs";
PostprocessingLensflare, webgpu_postprocessing_lensflare, "../../examples/webgpu_postprocessing_lensflare.rs";
PostprocessingDofBasic, webgpu_postprocessing_dof_basic, "../../examples/webgpu_postprocessing_dof_basic.rs";
PostprocessingDof, webgpu_postprocessing_dof, "../../examples/webgpu_postprocessing_dof.rs";
PostprocessingSsr, webgpu_postprocessing_ssr, "../../examples/webgpu_postprocessing_ssr.rs";
PostprocessingSmaa, webgpu_postprocessing_smaa, "../../examples/webgpu_postprocessing_smaa.rs";
PostprocessingPixel, webgpu_postprocessing_pixel, "../../examples/webgpu_postprocessing_pixel.rs";
PostprocessingSsgi, webgpu_postprocessing_ssgi, "../../examples/webgpu_postprocessing_ssgi.rs";
PostprocessingSss, webgpu_postprocessing_sss, "../../examples/webgpu_postprocessing_sss.rs";
Postprocessing3dlut, webgpu_postprocessing_3dlut, "../../examples/webgpu_postprocessing_3dlut.rs";
PostprocessingOutline, webgpu_postprocessing_outline, "../../examples/webgpu_postprocessing_outline.rs";
Oit, webgpu_oit, "../../examples/webgpu_oit.rs";
PostprocessingRetro, webgpu_postprocessing_retro, "../../examples/webgpu_postprocessing_retro.rs";
PostprocessingSsrDenoise, webgpu_postprocessing_ssr_denoise, "../../examples/webgpu_postprocessing_ssr_denoise.rs";
UpscalingFsr1, webgpu_upscaling_fsr1, "../../examples/webgpu_upscaling_fsr1.rs";
Clipping, webgpu_clipping, "../../examples/webgpu_clipping.rs";
ClippingStencil, webgpu_clipping_stencil, "../../examples/webgpu_clipping_stencil.rs";
LoaderGltfIridescence, webgpu_loader_gltf_iridescence, "../../examples/webgpu_loader_gltf_iridescence.rs";
MaterialsTransmission, webgpu_materials_transmission, "../../examples/webgpu_materials_transmission.rs";
UpscalingTaau, webgpu_upscaling_taau, "../../examples/webgpu_upscaling_taau.rs";}
impl Which {
fn parse(name: &str) -> Option<Self> {
let trimmed = name.trim_start_matches("webgpu_");
if let Some(index) = name.parse::<usize>().ok().filter(|i| *i >= 1) {
return Self::ALL.get(index - 1).copied();
}
Self::ALL
.into_iter()
.find(|which| which.short_name() == trimmed)
}
fn short_name(self) -> &'static str {
self.name().trim_start_matches("webgpu_")
}
fn next(self) -> Self {
let i = Self::ALL.iter().position(|w| *w == self).unwrap();
Self::ALL[(i + 1) % Self::ALL.len()]
}
fn previous(self) -> Self {
let i = Self::ALL.iter().position(|w| *w == self).unwrap();
Self::ALL[(i + Self::ALL.len() - 1) % Self::ALL.len()]
}
fn list() -> String {
Self::ALL
.iter()
.enumerate()
.map(|(index, which)| format!(" {:>2} {}", index + 1, which.name()))
.collect::<Vec<_>>()
.join("\n")
}
}
impl Example {
fn build(which: Which, instance: Option<wgpu::Instance>) -> Self {
let mut scene = Self::build_raw(which);
if let Some(instance) = instance {
let renderer = scene
.renderer()
.rebuilt_on(instance)
.expect("three-rs viewer: cannot create the renderer");
*scene.renderer() = renderer;
}
scene
}
fn set_size(&mut self, width: u32, height: u32) {
let (w, h) = (width.max(1) as f64, height.max(1) as f64);
self.resize_example(w, h);
if let Some(controls) = self.controls() {
controls.set_element_size(w, h);
}
}
}
struct FrameTimer {
samples: Vec<Duration>,
next: usize,
frames: u64,
}
impl FrameTimer {
const WARMUP: u64 = 10;
const WINDOW: usize = 60;
fn new() -> Self {
Self {
samples: Vec::with_capacity(Self::WINDOW),
next: 0,
frames: 0,
}
}
fn record(&mut self, sample: Duration) {
self.frames += 1;
if self.frames <= Self::WARMUP {
return;
}
if self.samples.len() < Self::WINDOW {
self.samples.push(sample);
} else {
self.samples[self.next] = sample;
}
self.next = (self.next + 1) % Self::WINDOW;
}
fn steady(&self) -> Option<(Duration, Duration, usize)> {
if self.samples.is_empty() {
return None;
}
let total: Duration = self.samples.iter().sum();
let max = *self.samples.iter().max().unwrap();
Some((total / self.samples.len() as u32, max, self.samples.len()))
}
fn report(&self) -> String {
match self.steady() {
Some((mean, max, count)) => format!(
"mean {:.2} ms max {:.2} ms (last {count} frames, after {} warm-up)",
mean.as_secs_f64() * 1e3,
max.as_secs_f64() * 1e3,
Self::WARMUP
),
None => format!("warming up ({} of {} frames)", self.frames, Self::WARMUP),
}
}
}
fn pointer_event(
cursor: (f64, f64),
button: Option<MouseButton>,
modifiers: (bool, bool),
) -> PointerEvent {
PointerEvent {
pointer_id: 1,
button: match button {
Some(MouseButton::Left) | None => OrbitButton::Left,
Some(MouseButton::Middle) => OrbitButton::Middle,
Some(MouseButton::Right) => OrbitButton::Right,
Some(_) => OrbitButton::Other,
},
client_x: cursor.0,
client_y: cursor.1,
ctrl_key: modifiers.0,
meta_key: false,
shift_key: modifiers.1,
}
}
struct Gpu {
window: Arc<Window>,
surface: wgpu::Surface<'static>,
format: wgpu::TextureFormat,
size: (u32, u32),
}
struct Viewer {
which: Which,
instance: Option<wgpu::Instance>,
scene: Option<Example>,
gpu: Option<Gpu>,
requested_size: (u32, u32),
frames: u32,
last_report: Instant,
timer: FrameTimer,
cursor: (f64, f64),
dragging: Option<MouseButton>,
modifiers: (bool, bool),
autoswitch: Option<f64>,
last_switch: Instant,
}
impl Viewer {
fn configure_surface(&mut self) {
let Some(gpu) = &mut self.gpu else { return };
let scene = self.scene.as_mut().unwrap();
let config = wgpu::SurfaceConfiguration {
usage: wgpu::TextureUsages::RENDER_ATTACHMENT,
format: gpu.format,
color_space: wgpu::SurfaceColorSpace::Auto,
view_formats: vec![gpu.format],
alpha_mode: wgpu::CompositeAlphaMode::Auto,
width: gpu.size.0.max(1),
height: gpu.size.1.max(1),
desired_maximum_frame_latency: 2,
present_mode: wgpu::PresentMode::AutoVsync,
};
gpu.surface.configure(scene.renderer().device(), &config);
}
fn switch(&mut self, which: Which) {
if which == self.which {
return;
}
println!("switching to {}", which.name());
self.which = which;
self.scene = None;
let instance = self.instance.clone();
let mut scene = Example::build(which, instance);
let size = self
.gpu
.as_ref()
.map(|g| g.size)
.unwrap_or(self.requested_size);
scene.set_size(size.0, size.1);
self.scene = Some(scene);
self.timer = FrameTimer::new();
self.configure_surface();
println!("{}", self.adapter_line());
}
fn adapter_line(&mut self) -> String {
let info = self.scene.as_mut().unwrap().renderer().adapter_info();
format!(
"adapter: {} ({:?}, {:?}) — {}",
info.name, info.device_type, info.backend, info.driver
)
}
fn redraw(&mut self) {
let Some(scene) = self.scene.as_mut() else {
return;
};
let t0 = Instant::now();
scene.animate();
let t_animate = t0.elapsed();
self.timer.record(t_animate);
let t1 = Instant::now();
if let Some(gpu) = &mut self.gpu {
let surface_texture = match gpu.surface.get_current_texture() {
wgpu::CurrentSurfaceTexture::Success(texture) => texture,
wgpu::CurrentSurfaceTexture::Suboptimal(texture) => {
drop(texture);
self.configure_surface();
return;
}
wgpu::CurrentSurfaceTexture::Occluded | wgpu::CurrentSurfaceTexture::Timeout => {
return
}
wgpu::CurrentSurfaceTexture::Outdated => {
self.configure_surface();
return;
}
wgpu::CurrentSurfaceTexture::Lost => {
gpu.surface = self
.instance
.as_ref()
.unwrap()
.create_surface(gpu.window.clone())
.unwrap();
self.configure_surface();
return;
}
wgpu::CurrentSurfaceTexture::Validation => {
panic!("three-rs viewer: surface validation error")
}
};
let view = surface_texture
.texture
.create_view(&wgpu::TextureViewDescriptor {
format: Some(gpu.format),
..Default::default()
});
let presented = scene.renderer().present(&view, gpu.format);
assert!(presented, "three-rs viewer: nothing to present");
gpu.window.pre_present_notify();
scene.renderer().queue().present(surface_texture);
}
if std::env::var("VIEWER_TRACE").is_ok() {
eprintln!(
"frame {}: animate {:?} present {:?}",
self.frames,
t_animate,
t1.elapsed()
);
}
self.frames += 1;
if self.last_report.elapsed().as_secs_f64() >= 1.0 {
let fps = self.frames as f64 / self.last_report.elapsed().as_secs_f64();
let (w, h) = self.gpu.as_ref().map(|g| g.size).unwrap_or((0, 0));
println!(
"{} — {w}x{h} — {fps:.1} fps — render {}",
self.which.name(),
self.timer.report()
);
self.frames = 0;
self.last_report = Instant::now();
}
}
}
impl ApplicationHandler for Viewer {
fn resumed(&mut self, event_loop: &ActiveEventLoop) {
if self.gpu.is_some() {
return;
}
let window = Arc::new(
event_loop
.create_window(
Window::default_attributes()
.with_title(format!("three-rs — {}", self.which.name()))
.with_inner_size(winit::dpi::LogicalSize::new(
self.requested_size.0,
self.requested_size.1,
)),
)
.expect("three-rs viewer: cannot create a window"),
);
let instance = wgpu::Instance::new(wgpu::InstanceDescriptor {
backends: three_rs::BACKENDS,
..wgpu::InstanceDescriptor::new_with_display_handle(Box::new(
event_loop.owned_display_handle(),
))
});
let surface = instance
.create_surface(window.clone())
.expect("three-rs viewer: cannot create a surface");
let mut scene = Example::build(self.which, Some(instance.clone()));
let caps = surface.get_capabilities(scene.renderer().adapter());
let preferred = caps.formats[0];
let linear = preferred.remove_srgb_suffix();
let format = if caps.formats.contains(&linear) {
linear
} else {
preferred
};
println!("surface formats: {:?} — using {format:?}", caps.formats);
let size = window.inner_size();
let size = (size.width.max(1), size.height.max(1));
scene.set_size(size.0, size.1);
self.instance = Some(instance);
self.scene = Some(scene);
self.gpu = Some(Gpu {
window: window.clone(),
surface,
format,
size,
});
self.requested_size = size;
self.configure_surface();
println!("{}", self.adapter_line());
println!(
"controls: left-drag orbit, right-drag pan, wheel dolly, arrows pan, \
[ and ] switch example, Esc quit"
);
println!("{}", Which::list());
window.request_redraw();
}
fn window_event(&mut self, event_loop: &ActiveEventLoop, _id: WindowId, event: WindowEvent) {
match event {
WindowEvent::CloseRequested => event_loop.exit(),
WindowEvent::ModifiersChanged(modifiers) => {
let state = modifiers.state();
self.modifiers = (state.control_key(), state.shift_key());
}
WindowEvent::KeyboardInput { event, .. } if event.state == ElementState::Pressed => {
match event.logical_key.as_ref() {
Key::Named(NamedKey::Escape) => event_loop.exit(),
Key::Character("[") => self.switch(self.which.previous()),
Key::Character("]") => self.switch(self.which.next()),
key => {
let arrow = match key {
Key::Named(NamedKey::ArrowLeft) => Some(OrbitKey::ArrowLeft),
Key::Named(NamedKey::ArrowUp) => Some(OrbitKey::ArrowUp),
Key::Named(NamedKey::ArrowRight) => Some(OrbitKey::ArrowRight),
Key::Named(NamedKey::ArrowDown) => Some(OrbitKey::ArrowDown),
_ => None,
};
let (Some(arrow), Some(scene)) = (arrow, self.scene.as_mut()) else {
return;
};
let event = KeyEvent {
key: arrow,
ctrl_key: self.modifiers.0,
meta_key: false,
shift_key: self.modifiers.1,
};
if let Some((controls, mut camera)) = scene.controls_and_camera() {
controls.key(&mut camera, &event);
}
}
}
}
WindowEvent::Resized(size) => {
let size = (size.width.max(1), size.height.max(1));
if let Some(gpu) = &mut self.gpu {
gpu.size = size;
}
if let Some(scene) = self.scene.as_mut() {
scene.set_size(size.0, size.1);
}
self.configure_surface();
}
WindowEvent::MouseInput { state, button, .. } => {
let pressed = state == ElementState::Pressed;
self.dragging = pressed.then_some(button);
let event = pointer_event(self.cursor, Some(button), self.modifiers);
let Some(scene) = self.scene.as_mut() else {
return;
};
if let Some((controls, mut camera)) = scene.controls_and_camera() {
if pressed {
controls.pointer_down(&mut camera, &event);
} else {
controls.pointer_up(&event);
}
}
}
WindowEvent::CursorMoved { position, .. } => {
self.cursor = (position.x, position.y);
let event = pointer_event(self.cursor, self.dragging, self.modifiers);
let Some(scene) = self.scene.as_mut() else {
return;
};
if let Some((controls, mut camera)) = scene.controls_and_camera() {
controls.pointer_move(&mut camera, &event);
}
}
WindowEvent::MouseWheel { delta, .. } => {
let (delta_y, delta_mode) = match delta {
MouseScrollDelta::LineDelta(_, y) => (-y as f64, WheelDelta::Line),
MouseScrollDelta::PixelDelta(p) => (-p.y, WheelDelta::Pixel),
};
let event = WheelEvent {
client_x: self.cursor.0,
client_y: self.cursor.1,
delta_y,
delta_mode,
ctrl_key: self.modifiers.0,
};
let Some(scene) = self.scene.as_mut() else {
return;
};
if let Some((controls, mut camera)) = scene.controls_and_camera() {
controls.wheel(&mut camera, &event);
}
}
WindowEvent::RedrawRequested => {
if let Some(period) = self.autoswitch {
if self.last_switch.elapsed().as_secs_f64() >= period {
self.last_switch = Instant::now();
self.switch(self.which.next());
}
}
self.redraw();
if let Some(gpu) = &self.gpu {
gpu.window.request_redraw();
}
}
_ => {}
}
}
}
fn write_strip(which: Which, scene: &mut Example) {
let strip = three_rs::testing::strip(
scene,
|scene| scene.renderer(),
&mut |scene: &mut Example| scene.animate(),
&mut [
("", &mut |_: &mut Example| {}),
("", &mut |_: &mut Example| {}),
],
)
.expect("three-rs viewer: the strip could not be read back");
for (index, frame) in strip.frames.iter().enumerate() {
println!(
"{}: strip frame {} — {}",
which.name(),
index + 1,
frame.info
);
}
let dir = std::path::Path::new(env!("CARGO_MANIFEST_DIR"))
.join("target/e2e")
.join(which.name());
std::fs::create_dir_all(&dir).expect("three-rs viewer: cannot create the strip directory");
let path = dir.join("strip.png");
strip.write_png(path.to_str().expect("three-rs viewer: the path is UTF-8"));
println!("{}: wrote {}", which.name(), path.display());
}
fn drive(scene: &mut Example, size: (u32, u32), orbit: (f64, f64), zoom: f64, pan: (f64, f64)) {
if orbit == (0.0, 0.0) && zoom == 0.0 && pan == (0.0, 0.0) {
return;
}
let centre = (size.0 as f64 / 2.0, size.1 as f64 / 2.0);
let Some((controls, mut camera)) = scene.controls_and_camera() else {
eprintln!(
"--orbit/--zoom/--pan ignored: this example's page creates no OrbitControls, \
so neither does it"
);
return;
};
let at = |button: OrbitButton, x: f64, y: f64| PointerEvent {
pointer_id: 1,
button,
client_x: x,
client_y: y,
ctrl_key: false,
meta_key: false,
shift_key: false,
};
if orbit != (0.0, 0.0) {
controls.pointer_down(&mut camera, &at(OrbitButton::Left, centre.0, centre.1));
controls.pointer_move(
&mut camera,
&at(OrbitButton::Left, centre.0 + orbit.0, centre.1 + orbit.1),
);
controls.pointer_up(&at(
OrbitButton::Left,
centre.0 + orbit.0,
centre.1 + orbit.1,
));
}
if zoom != 0.0 {
controls.wheel(
&mut camera,
&WheelEvent {
client_x: centre.0,
client_y: centre.1,
delta_y: -120.0 * zoom,
delta_mode: WheelDelta::Pixel,
ctrl_key: false,
},
);
}
if pan != (0.0, 0.0) {
controls.pointer_down(&mut camera, &at(OrbitButton::Right, centre.0, centre.1));
controls.pointer_move(
&mut camera,
&at(OrbitButton::Right, centre.0 + pan.0, centre.1 + pan.1),
);
controls.pointer_up(&at(OrbitButton::Right, centre.0 + pan.0, centre.1 + pan.1));
}
}
#[allow(clippy::too_many_arguments)] fn screenshot(
which: Which,
size: (u32, u32),
frames: u32,
path: Option<&str>,
orbit: (f64, f64),
zoom: f64,
pan: (f64, f64),
pinned: &[(String, f64)],
series: bool,
) {
if !pinned.is_empty() {
for (index, (label, time)) in pinned.iter().enumerate() {
three_rs::testing::pin_time(Some(time * 1000.0));
let mut scene = Example::build(which, None);
if index == 0 {
println!(
"adapter: {:?}",
scene.renderer().adapter_info().name.clone()
);
}
scene.set_size(size.0, size.1);
drive(&mut scene, size, orbit, zoom, pan);
for _ in 0..frames.max(1) {
scene.animate();
}
let Some(path) = path else { continue };
let (width, height, pixels) = scene.renderer().read_canvas_pixels().unwrap();
let out = if !series {
path.to_string()
} else {
format!("{}_{label}.png", path.trim_end_matches(".png"))
};
three_rs::testing::write_png(&out, width, height, &pixels);
println!(
"wrote {out} ({width}x{height}) at pinned t={time}s \
(Date.now() = performance.now() = {}ms)",
time * 1000.0
);
}
three_rs::testing::pin_time(None);
return;
}
let mut scene = Example::build(which, None);
println!(
"adapter: {:?}",
scene.renderer().adapter_info().name.clone()
);
scene.set_size(size.0, size.1);
drive(&mut scene, size, orbit, zoom, pan);
let mut timer = FrameTimer::new();
for frame in 0..frames.max(1) {
let t0 = Instant::now();
scene.animate();
scene
.renderer()
.device()
.poll(wgpu::PollType::wait_indefinitely())
.unwrap();
let elapsed = t0.elapsed();
timer.record(elapsed);
if std::env::var("VIEWER_TRACE").is_ok() {
eprintln!("frame {frame}: {:.2} ms", elapsed.as_secs_f64() * 1e3);
}
}
println!(
"{} — {}x{} — {frames} frame(s) headless — frame {}",
which.name(),
size.0,
size.1,
timer.report()
);
write_strip(which, &mut scene);
let Some(path) = path else { return };
let (width, height, pixels) = scene.renderer().read_canvas_pixels().unwrap();
three_rs::testing::write_png(path, width, height, &pixels);
println!("wrote {path} ({width}x{height}) after {frames} frame(s)");
let format = wgpu::TextureFormat::Bgra8Unorm;
let device = scene.renderer().device().clone();
let target = device.create_texture(&wgpu::TextureDescriptor {
label: Some("viewer present check"),
size: wgpu::Extent3d {
width,
height,
depth_or_array_layers: 1,
},
mip_level_count: 1,
sample_count: 1,
dimension: wgpu::TextureDimension::D2,
format,
usage: wgpu::TextureUsages::RENDER_ATTACHMENT | wgpu::TextureUsages::COPY_SRC,
view_formats: &[],
});
let view = target.create_view(&Default::default());
assert!(scene.renderer().present(&view, format));
let bytes_per_row = (width * 4).div_ceil(256) * 256;
let buffer = device.create_buffer(&wgpu::BufferDescriptor {
label: Some("viewer present readback"),
size: (bytes_per_row * height) as u64,
usage: wgpu::BufferUsages::COPY_DST | wgpu::BufferUsages::MAP_READ,
mapped_at_creation: false,
});
let mut encoder = device.create_command_encoder(&Default::default());
encoder.copy_texture_to_buffer(
wgpu::TexelCopyTextureInfo {
texture: &target,
mip_level: 0,
origin: wgpu::Origin3d::ZERO,
aspect: wgpu::TextureAspect::All,
},
wgpu::TexelCopyBufferInfo {
buffer: &buffer,
layout: wgpu::TexelCopyBufferLayout {
offset: 0,
bytes_per_row: Some(bytes_per_row),
rows_per_image: Some(height),
},
},
wgpu::Extent3d {
width,
height,
depth_or_array_layers: 1,
},
);
scene.renderer().queue().submit(Some(encoder.finish()));
let slice = buffer.slice(..);
slice.map_async(wgpu::MapMode::Read, |_| {});
device.poll(wgpu::PollType::wait_indefinitely()).unwrap();
let padded = slice.get_mapped_range().unwrap().to_vec();
buffer.unmap();
let mut rgba = Vec::with_capacity((width * height * 4) as usize);
for row in 0..height {
let start = (row * bytes_per_row) as usize;
for px in 0..width as usize {
let p = start + px * 4;
rgba.extend_from_slice(&[padded[p + 2], padded[p + 1], padded[p], padded[p + 3]]);
}
}
let present_path = path.replace(".png", "") + ".present.png";
three_rs::testing::write_png(&present_path, width, height, &rgba);
println!("wrote {present_path} (the blit Renderer::present() does)");
}
pub fn main() {
let args: Vec<String> = std::env::args().skip(1).collect();
let mut which = Which::ALL[0];
let mut size = (800u32, 500u32);
let mut frames = 1u32;
let mut shot: Option<String> = None;
let mut headless = false;
let mut orbit = (0.0f64, 0.0f64);
let mut zoom = 0.0f64;
let mut pan = (0.0f64, 0.0f64);
let mut pinned: Vec<(String, f64)> = Vec::new();
let mut series = false;
let mut i = 0;
while i < args.len() {
match args[i].as_str() {
"--list" => {
println!("{}", Which::list());
return;
}
"--headless" => headless = true,
"--screenshot" => {
i += 1;
shot = Some(args[i].clone());
}
"--orbit" => {
i += 1;
orbit.0 = args[i].parse().expect("--orbit takes two numbers");
i += 1;
orbit.1 = args[i].parse().expect("--orbit takes two numbers");
}
"--time" => {
i += 1;
let label = args[i].clone();
let time = label.parse().expect("--time takes a number of seconds");
pinned = vec![(label, time)];
series = false;
}
"--times" => {
i += 1;
series = true;
pinned = args[i]
.split(',')
.map(|part| {
let label = part.trim().to_string();
let time = label
.parse()
.expect("--times takes a comma-separated list of seconds");
(label, time)
})
.collect();
}
"--pan" => {
i += 1;
pan.0 = args[i].parse().expect("--pan takes two numbers");
i += 1;
pan.1 = args[i].parse().expect("--pan takes two numbers");
}
"--zoom" => {
i += 1;
zoom = args[i].parse().expect("--zoom takes a number");
}
"--frames" => {
i += 1;
frames = args[i].parse().expect("--frames takes a number");
}
"--width" => {
i += 1;
size.0 = args[i].parse().expect("--width takes a number");
}
"--height" => {
i += 1;
size.1 = args[i].parse().expect("--height takes a number");
}
other => match Which::parse(other) {
Some(w) => which = w,
None => {
eprintln!(
"usage: viewer <example | index> [--headless] [--screenshot out.png] \
[--frames N] [--width W] [--height H] [--orbit DX DY] \
[--zoom NOTCHES] [--pan DX DY] [--time T | --times T1,T2,...]\n\
\x20 viewer --list\n\nexamples:\n{}",
Which::list()
);
std::process::exit(2);
}
},
}
i += 1;
}
if headless || shot.is_some() {
screenshot(
which,
size,
frames,
shot.as_deref(),
orbit,
zoom,
pan,
&pinned,
series,
);
return;
}
let event_loop = EventLoop::new().expect("three-rs viewer: no event loop");
event_loop.set_control_flow(ControlFlow::Poll);
let now = Instant::now();
let mut viewer = Viewer {
which,
instance: None,
scene: None,
gpu: None,
requested_size: size,
frames: 0,
last_report: now,
timer: FrameTimer::new(),
cursor: (0.0, 0.0),
dragging: None,
modifiers: (false, false),
autoswitch: std::env::var("VIEWER_AUTOSWITCH")
.ok()
.and_then(|v| v.parse().ok()),
last_switch: now,
};
event_loop
.run_app(&mut viewer)
.expect("three-rs viewer: event loop failed");
}