use std::sync::Arc;
use std::time::Instant;
use crate::cameras::Camera;
use crate::helpers::{PointerButton, QuadView, QuadViewControls};
use crate::math::{Color, Vector2};
use crate::overlay::Overlay;
use crate::renderer::WindowRenderer;
use crate::{PerspectiveCamera, Scene};
pub fn run_window<I, H>(attributes: winit::window::WindowAttributes, init: I)
where
I: FnOnce(Arc<winit::window::Window>) -> H,
H: FnMut(winit::event::Event<()>, &winit::event_loop::ActiveEventLoop),
{
use winit::application::ApplicationHandler;
use winit::event::{DeviceEvent, DeviceId, Event, StartCause, WindowEvent};
use winit::event_loop::{ActiveEventLoop, EventLoop};
use winit::window::WindowId;
struct App<I, H> {
attributes: Option<winit::window::WindowAttributes>,
init: Option<I>,
handler: Option<H>,
}
impl<I, H> App<I, H>
where
H: FnMut(Event<()>, &ActiveEventLoop),
{
fn send(&mut self, event: Event<()>, target: &ActiveEventLoop) {
if let Some(handler) = self.handler.as_mut() {
handler(event, target);
}
}
}
impl<I, H> ApplicationHandler for App<I, H>
where
I: FnOnce(Arc<winit::window::Window>) -> H,
H: FnMut(Event<()>, &ActiveEventLoop),
{
fn new_events(&mut self, target: &ActiveEventLoop, cause: StartCause) {
self.send(Event::NewEvents(cause), target);
}
fn resumed(&mut self, target: &ActiveEventLoop) {
if let (Some(attributes), Some(init)) = (self.attributes.take(), self.init.take()) {
let window = Arc::new(target.create_window(attributes).expect("window"));
self.handler = Some(init(window));
}
self.send(Event::Resumed, target);
}
fn window_event(
&mut self,
target: &ActiveEventLoop,
window_id: WindowId,
event: WindowEvent,
) {
self.send(Event::WindowEvent { window_id, event }, target);
}
fn device_event(
&mut self,
target: &ActiveEventLoop,
device_id: DeviceId,
event: DeviceEvent,
) {
self.send(Event::DeviceEvent { device_id, event }, target);
}
fn about_to_wait(&mut self, target: &ActiveEventLoop) {
self.send(Event::AboutToWait, target);
}
fn suspended(&mut self, target: &ActiveEventLoop) {
self.send(Event::Suspended, target);
}
fn exiting(&mut self, target: &ActiveEventLoop) {
self.send(Event::LoopExiting, target);
}
fn memory_warning(&mut self, target: &ActiveEventLoop) {
self.send(Event::MemoryWarning, target);
}
}
let mut app = App {
attributes: Some(attributes),
init: Some(init),
handler: None,
};
EventLoop::new()
.expect("event loop")
.run_app(&mut app)
.expect("event loop");
}
#[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 pointer_inside: bool,
pub cursor_visible: 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};
let attributes = winit::window::Window::default_attributes()
.with_title(options.title.clone())
.with_inner_size(winit::dpi::LogicalSize::new(options.width, options.height));
run_window(attributes, move |window| {
let mut view = WindowRenderer::new(window.clone()).expect("a GPU for the window");
view.set_msaa(options.msaa);
view.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, view.aspect(), 0.1, 1000.0);
let mut overlay = Overlay::new(view.size().0, view.size().1);
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: view.size().0,
height: view.size().1,
};
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 mut pointer_inside = false;
let mut cursor_visible = true;
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;
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) => {
view.resize(s.width, s.height);
let (w, h) = view.size();
overlay.resize(w, h);
camera.set_aspect(view.aspect());
view.set_pixel_ratio(win.scale_factor() as f32);
}
WindowEvent::ScaleFactorChanged { scale_factor, .. } => {
view.set_pixel_ratio(scale_factor as f32);
}
WindowEvent::CursorEntered { .. } => pointer_inside = true,
WindowEvent::CursorLeft { .. } => pointer_inside = false,
WindowEvent::CursorMoved { position, .. } => {
pointer_inside = true;
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(view.size().0 as f32 / s, view.size().1 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(view.size().0 as f32 / s, view.size().1 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: view.size().0,
height: view.size().1,
pointer,
pointer_ndc: Vector2::new(
pointer.x / view.size().0.max(1) as f32 * 2.0 - 1.0,
1.0 - pointer.y / view.size().1.max(1) as f32 * 2.0,
),
pointer_down,
pointer_inside,
cursor_visible,
scale_factor: win.scale_factor() as f32,
exit: false,
};
draw(&mut f);
let wants_exit = f.exit;
if f.cursor_visible != cursor_visible {
cursor_visible = f.cursor_visible;
win.set_cursor_visible(cursor_visible);
}
frame_index += 1;
view.render_frame(&mut scene, &camera, quad_view.as_mut(), Some(&mut overlay));
if wants_exit {
target.exit();
}
win.request_redraw();
}
_ => {}
}
}
});
}