canary-rs/apps/magpie/src/service/window.rs

// Copyright (c) 2022 Marceline Cramer
// SPDX-License-Identifier: AGPL-3.0-or-later

use std::collections::HashMap;
use std::path::PathBuf;
use std::sync::Arc;
use std::time::Instant;

use canary::{CursorEventKind, Panel, Runtime, Vec2, PX_PER_MM};
use canary_wgpu::{wgpu, DrawTarget, Renderer};
use pollster::FutureExt;
use winit::dpi::PhysicalSize;
use winit::event::{ElementState, Event, MouseButton, WindowEvent};
use winit::event_loop::{ControlFlow, EventLoop, EventLoopProxy, EventLoopWindowTarget};
use winit::window::{WindowBuilder, WindowId};

use crate::service::ipc::{IpcMessage, IpcMessageSender};

#[derive(Clone, Debug)]
pub enum WindowMessage {
    OpenWindow {
        id: usize,
        protocol: String,
        script: PathBuf,
    },
    CloseWindow {
        id: usize,
    },
    Quit,
    SendMessage {
        id: usize,
        msg: Vec<u8>,
    },
}

pub type WindowMessageSender = EventLoopProxy<WindowMessage>;

pub struct Window {
    pub ipc_sender: IpcMessageSender,
    pub ipc_id: usize,
    pub window: winit::window::Window,
    pub surface: wgpu::Surface,
    pub surface_config: wgpu::SurfaceConfiguration,
    pub device: Arc<wgpu::Device>,
    pub queue: Arc<wgpu::Queue>,
    pub renderer: Arc<Renderer>,
    pub panel: Panel,
    pub last_update: Instant,
    pub cursor_pos: Vec2,
    pub cursor_down: bool,
}

impl Window {
    pub fn new(
        ipc_sender: IpcMessageSender,
        ipc_id: usize,
        panel: Panel,
        instance: &wgpu::Instance,
        adapter: &wgpu::Adapter,
        device: Arc<wgpu::Device>,
        queue: Arc<wgpu::Queue>,
        renderer: Arc<Renderer>,
        event_loop: &EventLoopWindowTarget<WindowMessage>,
    ) -> anyhow::Result<Self> {
        let window = WindowBuilder::new()
            .with_transparent(true)
            .build(&event_loop)?;
        let surface = unsafe { instance.create_surface(&window) };
        let last_update = Instant::now();

        let size = window.inner_size();

        let surface_config = wgpu::SurfaceConfiguration {
            usage: wgpu::TextureUsages::RENDER_ATTACHMENT,
            format: wgpu::TextureFormat::Bgra8Unorm,
            width: size.width,
            height: size.height,
            present_mode: wgpu::PresentMode::Fifo,
        };

        surface.configure(&device, &surface_config);

        Ok(Self {
            ipc_sender,
            ipc_id,
            window,
            surface,
            surface_config,
            device,
            queue,
            renderer,
            panel,
            last_update,
            cursor_pos: Vec2::ZERO,
            cursor_down: false,
        })
    }

    pub fn get_id(&self) -> WindowId {
        self.window.id()
    }

    pub fn request_redraw(&mut self) {
        self.window.request_redraw();
    }

    /// Receives all messages from the script and forwards them to IPC.
    pub fn recv_messages(&mut self) {
        for message in self.panel.recv_messages() {
            self.ipc_sender.send(IpcMessage::PanelMessage {
                window: self.ipc_id,
                message,
            });
        }
    }

    pub fn update(&mut self) {
        let now = Instant::now();
        let dt = now.duration_since(self.last_update).as_secs_f32();
        self.panel.update(dt);
        self.last_update = now;
        self.recv_messages();
    }

    pub fn draw(&mut self) {
        let output = self.surface.get_current_texture().unwrap();
        let view = output.texture.create_view(&Default::default());
        let commands = self.panel.draw();

        let size = Vec2::new(
            self.surface_config.width as f32,
            self.surface_config.height as f32,
        ) * PX_PER_MM;

        let target = DrawTarget {
            texture: &view,
            size,
        };

        self.renderer.render(target, &commands);

        output.present();

        self.recv_messages();
    }

    pub fn send_message(&mut self, msg: Vec<u8>) {
        self.panel.on_message(msg);
        self.recv_messages();
    }

    pub fn resize(&mut self, new_size: PhysicalSize<u32>) {
        let mm = Vec2::new(new_size.width as f32, new_size.height as f32) * PX_PER_MM;
        self.panel.on_resize(mm);
        self.recv_messages();
        self.window.request_redraw();

        if new_size.width > 0 && new_size.height > 0 {
            self.surface_config.width = new_size.width;
            self.surface_config.height = new_size.height;
            self.surface.configure(&self.device, &self.surface_config);
        }
    }

    pub fn on_event(&mut self, event: WindowEvent) {
        match event {
            WindowEvent::Resized(size) => self.resize(size),
            WindowEvent::ScaleFactorChanged { new_inner_size, .. } => self.resize(*new_inner_size),
            WindowEvent::CursorMoved { position, .. } => {
                let x = position.x as f32 * PX_PER_MM;
                let y = position.y as f32 * PX_PER_MM;
                self.cursor_pos = Vec2::new(x, y);

                let event = if self.cursor_down {
                    CursorEventKind::Drag
                } else {
                    CursorEventKind::Hover
                };

                self.panel.on_cursor_event(event, self.cursor_pos);
                self.recv_messages();
            }
            WindowEvent::MouseInput {
                state,
                button: MouseButton::Left,
                ..
            } => {
                let event = match state {
                    ElementState::Pressed => {
                        self.cursor_down = true;
                        CursorEventKind::Select
                    }
                    ElementState::Released => {
                        self.cursor_down = false;
                        CursorEventKind::Deselect
                    }
                };

                self.panel.on_cursor_event(event, self.cursor_pos);
                self.recv_messages();
            }
            _ => {}
        }
    }
}

pub struct WindowStore {
    pub ipc_sender: IpcMessageSender,
    pub ipc_to_window: HashMap<usize, WindowId>,
    pub windows: HashMap<WindowId, Window>,
    pub runtime: Runtime,
    pub instance: wgpu::Instance,
    pub adapter: wgpu::Adapter,
    pub device: Arc<wgpu::Device>,
    pub queue: Arc<wgpu::Queue>,
    pub renderer: Arc<Renderer>,
}

impl WindowStore {
    pub fn new(ipc_sender: IpcMessageSender) -> Self {
        let backend = canary::backend::make_default_backend().unwrap();
        let runtime = Runtime::new(backend).unwrap();

        let instance = wgpu::Instance::new(wgpu::Backends::all());
        let adapter = instance
            .request_adapter(&wgpu::RequestAdapterOptionsBase {
                power_preference: wgpu::PowerPreference::HighPerformance,
                force_fallback_adapter: false,
                compatible_surface: None,
            })
            .block_on()
            .unwrap();
        let (device, queue) = adapter
            .request_device(
                &wgpu::DeviceDescriptor {
                    label: None,
                    features: wgpu::Features::empty(),
                    limits: wgpu::Limits::default(),
                },
                None,
            )
            .block_on()
            .unwrap();

        let device = Arc::new(device);
        let queue = Arc::new(queue);
        let renderer = Renderer::new(device.to_owned(), queue.to_owned());
        let renderer = Arc::new(renderer);

        Self {
            ipc_sender,
            ipc_to_window: Default::default(),
            windows: Default::default(),
            runtime,
            instance,
            adapter,
            device,
            queue,
            renderer,
        }
    }

    pub fn get_ipc_window(&mut self, id: usize) -> Option<&mut Window> {
        self.ipc_to_window
            .get(&id)
            .map(|id| self.windows.get_mut(id))
            .flatten()
    }

    pub fn on_message(
        &mut self,
        event_loop: &EventLoopWindowTarget<WindowMessage>,
        message: WindowMessage,
    ) -> anyhow::Result<bool> {
        match message {
            WindowMessage::OpenWindow {
                id,
                protocol,
                script,
            } => {
                println!("Opening window {} with script {:?}", id, script);
                let module = std::fs::read(script)?;
                let mut script = self.runtime.load_module(&module)?;
                let panel = script.create_panel(&protocol, vec![])?;

                let window = Window::new(
                    self.ipc_sender.to_owned(),
                    id,
                    panel,
                    &self.instance,
                    &self.adapter,
                    self.device.to_owned(),
                    self.queue.to_owned(),
                    self.renderer.to_owned(),
                    &event_loop,
                )?;

                let window_id = window.get_id();
                self.windows.insert(window_id, window);
                self.ipc_to_window.insert(id, window_id);
            }
            WindowMessage::CloseWindow { id } => {
                if let Some(window_id) = self.ipc_to_window.remove(&id) {
                    self.windows.remove(&window_id);
                }
            }
            WindowMessage::Quit => return Ok(true),
            WindowMessage::SendMessage { id, msg } => {
                if let Some(window) = self.get_ipc_window(id) {
                    window.send_message(msg);
                }
            }
        };

        Ok(false)
    }

    pub fn run(mut self, event_loop: EventLoop<WindowMessage>) -> ! {
        event_loop.run(move |event, event_loop, control_flow| match event {
            Event::WindowEvent { window_id, event } => {
                if let Some(window) = self.windows.get_mut(&window_id) {
                    window.on_event(event);
                }
            }
            Event::RedrawRequested(id) => {
                if let Some(window) = self.windows.get_mut(&id) {
                    window.draw();
                }
            }
            Event::MainEventsCleared => {
                for (_id, window) in self.windows.iter_mut() {
                    window.update();
                    window.request_redraw();
                }
            }
            Event::UserEvent(event) => match self.on_message(event_loop, event.clone()) {
                Ok(false) => {}
                Ok(true) => *control_flow = ControlFlow::Exit,
                Err(err) => {
                    eprintln!("Error while handling message {:?}:\n{}", event, err);
                }
            },
            _ => {}
        });
    }
}