canary-rs/src/lib.rs

// Copyright (c) 2022 Marceline Cramer
// SDPX-License-Identifier: LGPL-3.0-or-later

pub use canary_script::*;
use parking_lot::{Mutex, RwLock};
use slab::Slab;
use std::collections::HashMap;
use std::sync::Arc;

pub mod backend;
pub mod text;

use backend::{Backend, Instance};

/// The main interface to Canary.
pub struct Runtime {
    backend: Box<dyn Backend>,
}

impl Runtime {
    pub fn new(backend: Box<dyn Backend>) -> anyhow::Result<Self> {
        Ok(Self { backend })
    }

    pub fn load_module(&self, module: &[u8]) -> anyhow::Result<Script> {
        let instance = self.backend.load_module(module)?;

        Ok(Script {
            instance,
            next_panel: 0,
        })
    }
}

/// A loaded instance of a Canary script.
pub struct Script {
    instance: Arc<dyn Instance>,
    next_panel: usize,
}

impl Script {
    pub fn create_panel(&mut self, msg: Vec<u8>) -> anyhow::Result<Panel> {
        let id = PanelId(self.next_panel);
        self.next_panel += 1;
        let userdata = self.instance.bind_panel(id, msg);
        Ok(Panel {
            instance: self.instance.clone(),
            id,
            userdata,
        })
    }
}

/// A Canary panel.
pub struct Panel {
    instance: Arc<dyn Instance>,
    id: PanelId,
    userdata: u32,
}

impl Panel {
    pub fn update(&self, dt: f32) {
        self.instance.update(self.userdata, dt);
    }

    pub fn draw(&self) -> Vec<DrawCommand> {
        self.instance.draw(self.userdata)
    }

    pub fn on_resize(&self, new_size: Vec2) {
        self.instance.on_resize(self.userdata, new_size);
    }

    pub fn on_cursor_event(&self, kind: CursorEventKind, at: Vec2) {
        self.instance.on_cursor_event(self.userdata, kind, at);
    }

    pub fn on_message(&self, msg: Vec<u8>) {
        self.instance.on_message(self.userdata, msg);
    }
}

/// Proportion constant between pixels (at 96dpi) to millimeters (Canary's unit measurement).
pub const PX_PER_MM: f32 = 25.4 / 96.0;

/// Low-level script API callbacks.
///
/// If you're a casual user of Canary the struct you're looking for is
/// [ScriptAbiImpl]. This trait exists to help with making mocks for testing.
pub trait ScriptAbi {
    fn start_draw(&self);
    fn draw_indexed(&self, vertices: &[MeshVertex], indices: &[MeshIndex]);
    fn draw_text_layout(&self, id: u32, offset: Vec2, scale: f32, color: Color);
    fn with_draw_commands(&self, f: impl FnOnce(&[DrawCommand]));

    fn font_load(&self, family: &str) -> u32;

    fn text_layout_new(&self, font_id: u32, text: &str) -> u32;
    fn text_layout_delete(&self, id: u32);
    fn text_layout_get_bounds(&self, id: u32, rect: &mut Rect);

    fn message_new(&self, data: Vec<u8>) -> u32;
    fn message_free(&self, id: u32);
    fn message_get_len(&self, id: u32) -> u32;
    fn message_get_data(&self, id: u32, dst: &mut [u8]);
}

#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub struct PanelId(pub(crate) usize);

#[non_exhaustive]
#[derive(Clone, Debug)]
pub enum DrawCommand {
    Mesh {
        vertices: Vec<MeshVertex>,
        indices: Vec<MeshIndex>,
    },
}

/// The standard [ScriptAbi] implementation to use.
#[derive(Default)]
pub struct ScriptAbiImpl {
    draw_cmds: Mutex<Vec<DrawCommand>>,
    font_store: text::FontStore,
    font_families: Mutex<HashMap<String, u32>>,
    loaded_fonts: RwLock<Vec<Arc<text::Font>>>,
    text_layouts: RwLock<Slab<text::TextLayout>>,
    message_store: RwLock<Slab<Vec<u8>>>,
}

impl ScriptAbi for ScriptAbiImpl {
    fn start_draw(&self) {
        let mut lock = self.draw_cmds.lock();
        lock.clear();
    }

    fn draw_indexed(&self, vertices: &[MeshVertex], indices: &[MeshIndex]) {
        self.draw_cmds.lock().push(DrawCommand::Mesh {
            vertices: vertices.to_vec(),
            indices: indices.to_vec(),
        })
    }

    fn draw_text_layout(&self, id: u32, offset: Vec2, scale: f32, color: Color) {
        // TODO multiple fonts per layout
        let layouts = self.text_layouts.read();
        let layout = layouts.get(id as usize).unwrap();
        let glyphs = layout.glyphs.as_slice();
        let loaded = self.loaded_fonts.read();
        let font = loaded.get(layout.font_id as usize).unwrap();
        let cmds = font.draw(glyphs, offset, scale, color);
        self.draw_cmds.lock().extend(cmds.into_iter());
    }

    fn with_draw_commands(&self, f: impl FnOnce(&[DrawCommand])) {
        f(self.draw_cmds.lock().as_slice());
    }

    fn font_load(&self, family: &str) -> u32 {
        let mut family_cache = self.font_families.lock();

        if let Some(cached) = family_cache.get(family) {
            return *cached;
        }

        let font = self.font_store.load_font(family);
        let mut loaded = self.loaded_fonts.write();
        let id = loaded.len() as u32;
        family_cache.insert(family.to_string(), id);
        loaded.push(font);
        id
    }

    fn text_layout_new(&self, font_id: u32, text: &str) -> u32 {
        let loaded = self.loaded_fonts.read();
        let font = loaded.get(font_id as usize).unwrap();
        let layout = font.shape(text);
        self.text_layouts.write().insert(layout) as u32
    }

    fn text_layout_delete(&self, id: u32) {
        self.text_layouts.write().remove(id as usize);
    }

    fn text_layout_get_bounds(&self, id: u32, dst: &mut Rect) {
        let src = self.text_layouts.read().get(id as usize).unwrap().bounds;
        let _ = std::mem::replace(dst, src);
    }

    fn message_new(&self, data: Vec<u8>) -> u32 {
        let mut store = self.message_store.write();
        let id = store.insert(data) as u32;
        id
    }

    fn message_free(&self, id: u32) {
        let mut store = self.message_store.write();
        store.remove(id as usize);
    }

    fn message_get_len(&self, id: u32) -> u32 {
        self.message_store.read().get(id as usize).unwrap().len() as u32
    }

    fn message_get_data(&self, id: u32, dst: &mut [u8]) {
        let store = self.message_store.read();
        let src = store.get(id as usize).unwrap();
        dst.copy_from_slice(src);
    }
}