use std::sync::Arc;
use std::time::Instant;
use crate::cameras::Camera;
use crate::helpers::{PointerButton, QuadView, QuadViewControls, ViewSurface};
use crate::math::{Color, Vector2};
use crate::overlay::Overlay;
use crate::{PerspectiveCamera, Renderer, Scene};
#[derive(Debug, Clone)]
pub struct SketchOptions {
pub title: String,
pub width: u32,
pub height: u32,
pub background: Color,
pub fov: f32,
pub msaa: u32,
pub quad_view: Option<QuadView>,
pub quad_controls: bool,
}
impl SketchOptions {
pub fn new(title: impl Into<String>) -> Self {
Self {
title: title.into(),
..Default::default()
}
}
pub fn size(mut self, width: u32, height: u32) -> Self {
self.width = width;
self.height = height;
self
}
pub fn background(mut self, color: Color) -> Self {
self.background = color;
self
}
pub fn fov(mut self, degrees: f32) -> Self {
self.fov = degrees;
self
}
pub fn msaa(mut self, samples: u32) -> Self {
self.msaa = samples;
self
}
pub fn quad_view(mut self, quad: QuadView) -> Self {
self.quad_view = Some(quad);
self
}
pub fn quad_controls(mut self, on: bool) -> Self {
self.quad_controls = on;
self
}
}
impl Default for SketchOptions {
fn default() -> Self {
Self {
title: "threers".into(),
width: 960,
height: 720,
background: Color::from_hex(0x101018),
fov: 60.0,
msaa: 1,
quad_view: None,
quad_controls: true,
}
}
}
pub struct Setup<'a> {
pub scene: &'a mut Scene,
pub camera: &'a mut PerspectiveCamera,
pub scale_factor: f32,
pub overlay: &'a mut Overlay,
pub quad_view: Option<&'a mut QuadView>,
pub width: u32,
pub height: u32,
}
pub struct Frame<'a> {
pub scene: &'a mut Scene,
pub camera: &'a mut PerspectiveCamera,
pub overlay: &'a mut Overlay,
pub quad_view: Option<&'a mut QuadView>,
pub frame: u64,
pub elapsed: f32,
pub delta: f32,
pub width: u32,
pub height: u32,
pub pointer: Vector2,
pub pointer_ndc: Vector2,
pub pointer_down: bool,
pub scale_factor: f32,
pub exit: bool,
}
pub fn sketch<D, S>(options: SketchOptions, setup: S)
where
S: FnOnce(&mut Setup) -> D,
D: FnMut(&mut Frame) + 'static,
{
use winit::event::{ElementState, Event, MouseButton, MouseScrollDelta, WindowEvent};
use winit::event_loop::EventLoop;
use winit::window::WindowBuilder;
let event_loop = EventLoop::new().expect("event loop");
let window = Arc::new(
WindowBuilder::new()
.with_title(options.title.clone())
.with_inner_size(winit::dpi::LogicalSize::new(options.width, options.height))
.build(&event_loop)
.expect("window"),
);
let instance = {
let mut d = wgpu::InstanceDescriptor::new_without_display_handle();
d.backends = wgpu::Backends::PRIMARY;
wgpu::Instance::new(d)
};
let surface = instance.create_surface(window.clone()).expect("surface");
let adapter = pollster::block_on(instance.request_adapter(&wgpu::RequestAdapterOptions {
power_preference: wgpu::PowerPreference::default(),
compatible_surface: Some(&surface),
force_fallback_adapter: false,
apply_limit_buckets: false,
}))
.expect("no GPU adapter");
let adapter_limits = adapter.limits();
let mut limits = wgpu::Limits::downlevel_defaults().using_resolution(adapter_limits.clone());
limits.max_sampled_textures_per_shader_stage =
adapter_limits.max_sampled_textures_per_shader_stage;
limits.max_samplers_per_shader_stage = adapter_limits.max_samplers_per_shader_stage;
let (device, queue) = pollster::block_on(adapter.request_device(&wgpu::DeviceDescriptor {
label: Some("threers sketch"),
required_features: wgpu::Features::empty(),
required_limits: limits,
..Default::default()
}))
.expect("device");
let device = Arc::new(device);
let queue = Arc::new(queue);
let size = window.inner_size();
let caps = surface.get_capabilities(&adapter);
let format = caps
.formats
.iter()
.copied()
.find(|f| f.is_srgb())
.unwrap_or(caps.formats[0]);
let srgb_format = format.add_srgb_suffix();
let mut config = wgpu::SurfaceConfiguration {
usage: wgpu::TextureUsages::RENDER_ATTACHMENT,
format,
width: size.width.max(1),
height: size.height.max(1),
present_mode: caps.present_modes[0],
alpha_mode: caps.alpha_modes[0],
view_formats: if srgb_format == format {
vec![]
} else {
vec![srgb_format]
},
desired_maximum_frame_latency: 2,
color_space: wgpu::SurfaceColorSpace::Srgb,
};
surface.configure(&device, &config);
let mut renderer = Renderer::new(
device.clone(),
queue.clone(),
format,
config.width,
config.height,
);
if options.msaa > 1 {
renderer.set_msaa(options.msaa);
}
renderer.set_pixel_ratio(window.scale_factor() as f32);
let mut quad_view = options.quad_view.clone();
let mut scene = Scene::new();
scene.background = options.background;
let mut camera = PerspectiveCamera::new(
options.fov,
config.width as f32 / config.height as f32,
0.1,
1000.0,
);
let mut overlay = Overlay::new(config.width, config.height);
let mut draw = {
let mut s = Setup {
scene: &mut scene,
camera: &mut camera,
overlay: &mut overlay,
quad_view: quad_view.as_mut(),
scale_factor: window.scale_factor() as f32,
width: config.width,
height: config.height,
};
setup(&mut s)
};
let start = Instant::now();
let mut last = start;
let mut frame_index: u64 = 0;
let mut pointer = Vector2::new(0.0, 0.0);
let mut pointer_down = false;
let win = window.clone();
let mut quad_controls = (options.quad_controls && quad_view.is_some())
.then(|| QuadViewControls::new(&camera));
let mut last_click: Option<(Instant, Vector2)> = None;
event_loop
.run(move |event, target| {
let Event::WindowEvent { event, window_id } = event else {
return;
};
if window_id != win.id() {
return;
}
match event {
WindowEvent::CloseRequested => target.exit(),
WindowEvent::Resized(s) => {
config.width = s.width.max(1);
config.height = s.height.max(1);
surface.configure(&device, &config);
renderer.resize(config.width, config.height);
overlay.resize(config.width, config.height);
camera.set_aspect(config.width as f32 / config.height as f32);
renderer.set_pixel_ratio(win.scale_factor() as f32);
}
WindowEvent::ScaleFactorChanged { scale_factor, .. } => {
renderer.set_pixel_ratio(scale_factor as f32);
}
WindowEvent::CursorMoved { position, .. } => {
pointer = Vector2::new(position.x as f32, position.y as f32);
if let (Some(ctl), Some(quad)) = (quad_controls.as_mut(), quad_view.as_mut()) {
let s = win.scale_factor() as f32;
ctl.pointer_move(quad, &mut camera, pointer.x / s, pointer.y / s);
}
}
WindowEvent::MouseInput { state, button, .. } => {
if button == MouseButton::Left {
pointer_down = state == ElementState::Pressed;
}
if let (Some(ctl), Some(quad)) = (quad_controls.as_mut(), quad_view.as_mut()) {
let s = win.scale_factor() as f32;
ctl.set_size(config.width as f32 / s, config.height as f32 / s);
let (x, y) = (pointer.x / s, pointer.y / s);
let button = match button {
MouseButton::Left => Some(PointerButton::Primary),
MouseButton::Middle => Some(PointerButton::Middle),
MouseButton::Right => Some(PointerButton::Secondary),
_ => None,
};
match (state, button) {
(ElementState::Pressed, Some(PointerButton::Primary)) => {
let now = Instant::now();
let double = last_click.is_some_and(|(t, at)| {
now.duration_since(t).as_millis() < 400
&& (at - pointer).length() < 6.0 * s
});
if double {
last_click = None;
ctl.dblclick(quad, x, y);
} else {
last_click = Some((now, pointer));
ctl.pointer_down(quad, &camera, x, y, PointerButton::Primary);
}
}
(ElementState::Pressed, Some(b)) => {
ctl.pointer_down(quad, &camera, x, y, b);
}
(ElementState::Released, Some(_)) => ctl.pointer_up(),
_ => {}
}
}
}
WindowEvent::MouseWheel { delta, .. } => {
if let (Some(ctl), Some(quad)) = (quad_controls.as_mut(), quad_view.as_mut()) {
let s = win.scale_factor() as f32;
ctl.set_size(config.width as f32 / s, config.height as f32 / s);
let d = match delta {
MouseScrollDelta::LineDelta(_, y) => -y * 100.0,
MouseScrollDelta::PixelDelta(p) => -(p.y as f32) / s,
};
ctl.wheel(quad, &mut camera, pointer.x / s, pointer.y / s, d);
}
}
WindowEvent::RedrawRequested => {
let now = Instant::now();
let delta = now.duration_since(last).as_secs_f32();
last = now;
overlay.clear();
let mut f = Frame {
scene: &mut scene,
camera: &mut camera,
overlay: &mut overlay,
quad_view: quad_view.as_mut(),
frame: frame_index,
elapsed: start.elapsed().as_secs_f32(),
delta,
width: config.width,
height: config.height,
pointer,
pointer_ndc: Vector2::new(
pointer.x / config.width.max(1) as f32 * 2.0 - 1.0,
1.0 - pointer.y / config.height.max(1) as f32 * 2.0,
),
pointer_down,
scale_factor: win.scale_factor() as f32,
exit: false,
};
draw(&mut f);
let wants_exit = f.exit;
frame_index += 1;
if config.width > 0 && config.height > 0 {
if let wgpu::CurrentSurfaceTexture::Success(frame)
| wgpu::CurrentSurfaceTexture::Suboptimal(frame) =
surface.get_current_texture()
{
let view = frame
.texture
.create_view(&wgpu::TextureViewDescriptor::default());
match quad_view.as_mut() {
Some(quad) => quad.render(
&mut ViewSurface {
renderer: &mut renderer,
view: &view,
linear_framebuffer: false,
},
&mut scene,
&camera,
),
None => renderer.render(&mut scene, &camera, &view, false),
}
if overlay.touched() {
let srgb_view = if srgb_format == config.format {
None
} else {
Some(frame.texture.create_view(
&wgpu::TextureViewDescriptor {
format: Some(srgb_format),
..Default::default()
},
))
};
renderer.draw_overlay(
&mut overlay,
srgb_view.as_ref().unwrap_or(&view),
srgb_format,
);
}
queue.present(frame);
}
}
if wants_exit {
target.exit();
}
win.request_redraw();
}
_ => {}
}
})
.expect("event loop");
}