Initial commit

.gitignore

@@ -0,0 +1,2 @@
+/target
+/Cargo.lock

Cargo.toml

@@ -0,0 +1,19 @@
+[workspace]
+members = [
+  "crates/egui",
+  "crates/sao-ui-rs",
+  "crates/script",
+	"crates/types",
+]
+
+[package]
+name = "canary"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]
+anyhow = "1"
+bytemuck = "1"
+canary_types = { path = "crates/types" }
+parking_lot = "0.12"
+wasmtime = "0.38"

crates/egui/Cargo.toml

@@ -0,0 +1,8 @@
+[package]
+name = "canary_egui_harness"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]
+canary = { path = "../.." }
+eframe = "0.18"

crates/egui/src/main.rs

@@ -0,0 +1,118 @@
+use canary::ScriptInstance;
+use eframe::egui;
+use std::time::Instant;
+
+fn main() {
+    let args: Vec<String> = std::env::args().collect();
+    let module_path = args
+        .get(1)
+        .expect("Please pass a path to a Canary script!")
+        .to_owned();
+
+    let native_options = eframe::NativeOptions {
+        multisampling: 8,
+        ..Default::default()
+    };
+
+    eframe::run_native(
+        "Canary egui Harness",
+        native_options,
+        Box::new(move |cc| {
+            cc.egui_ctx.set_visuals(egui::Visuals::dark());
+            Box::new(App::new(&module_path))
+        }),
+    );
+}
+
+struct App {
+    script: canary::WasmtimeScript<canary::SimpleScriptAbi>,
+    last_update: Instant,
+}
+
+impl App {
+    pub fn new(module_path: &str) -> Self {
+        let runtime = canary::WasmtimeRuntime::new().unwrap();
+        let abi = canary::SimpleScriptAbi::default();
+        let module = std::fs::read(module_path).unwrap();
+        let script = runtime.load_module(abi, &module).unwrap();
+
+        Self {
+            script,
+            last_update: Instant::now(),
+        }
+    }
+}
+
+impl eframe::App for App {
+    fn update(&mut self, ctx: &egui::Context, _frame: &mut eframe::Frame) {
+        ctx.request_repaint();
+
+        let dt = self.last_update.elapsed().as_secs_f32();
+        self.last_update = Instant::now();
+        self.script.update(dt);
+
+        egui::Window::new("Panel").show(ctx, |ui| {
+            let size = egui::vec2(800.0, 800.0);
+            let sense = egui::Sense {
+                click: true,
+                drag: true,
+                focusable: false,
+            };
+
+            let (rect, response) = ui.allocate_at_least(size, sense);
+
+            // TODO input events
+            /*let input = ui.input();
+            for event in input.events.iter() {
+                let event = match event {
+                    egui::Event::PointerMoved(pos) => {
+                        if input.pointer.primary_down() {
+                            Some(())
+                        }
+                    }
+                    _ => None,
+                };
+
+                if let Some((kind, x, y)) = event {
+                    self.script.on_cursor_event(kind, canary::Vec2 { x, y });
+                }
+            }*/
+
+            let texture = egui::TextureId::Managed(0);
+            let uv = egui::pos2(0.0, 0.0);
+            let mut mesh = egui::Mesh::with_texture(texture);
+
+            self.script.draw(|commands| {
+                for command in commands.iter() {
+                    let voff = mesh.vertices.len() as u32;
+
+                    match command {
+                        canary::DrawCommand::Mesh { vertices, indices } => {
+                            for v in vertices.iter() {
+                                use egui::epaint::Vertex;
+                                let pos = egui::pos2(v.position.x, -v.position.y);
+                                let pos = pos.to_vec2() / 2.0 + egui::vec2(0.5, 0.5);
+                                let pos = rect.left_top() + pos * rect.size();
+                                let (r, g, b, a) = v.color.to_rgba_unmultiplied();
+                                let color = egui::Color32::from_rgba_unmultiplied(r, g, b, a);
+                                let v = Vertex { pos, uv, color };
+                                mesh.vertices.push(v);
+                            }
+
+                            for i in indices.iter() {
+                                mesh.indices.push(i + voff);
+                            }
+                        }
+                        _ => unimplemented!(),
+                    }
+                }
+            });
+
+            let painter = ui.painter_at(rect);
+            let shape = egui::Shape::mesh(mesh);
+            painter.add(shape);
+
+            response
+        });
+    }
+}

crates/sao-ui-rs/Cargo.toml

@@ -0,0 +1,18 @@
+[package]
+name = "sao-ui-rs"
+version = "0.1.0"
+edition = "2021"
+
+[lib]
+crate-type = ["cdylib"]
+
+[dependencies]
+bitflags = "^1"
+glam = "^0.21"
+keyframe = "1"
+canary_script = { path = "../script", features = ["glam"] }
+wee_alloc = "^0.4"
+
+[profile.release]
+opt-level = 3
+lto = "fat"

crates/sao-ui-rs/src/anim.rs

@@ -0,0 +1,131 @@
+use keyframe::EasingFunction;
+use crate::Color;
+
+pub trait AnimationLerp<T> {
+    fn lerp(&self, x: f32) -> T;
+}
+
+#[derive(Clone)]
+pub struct Animation<F, T = f32> {
+    time: f32,
+    duration: f32,
+    in_delay: f32,
+    out_delay: f32,
+    from: T,
+    to: T,
+    function: F,
+    direction: bool,
+}
+
+impl<F: EasingFunction, T: Copy> Animation<F, T> {
+    pub fn new(function: F, duration: f32, from: T, to: T) -> Self {
+        Self {
+            time: duration,
+            duration,
+            from,
+            to,
+            in_delay: 0.0,
+            out_delay: 0.0,
+            function,
+            direction: false,
+        }
+    }
+
+    pub fn update(&mut self, dt: f32) {
+        self.time += dt;
+    }
+
+    pub fn is_active(&self) -> bool {
+        self.time < self.duration
+    }
+
+    pub fn ease_in(&mut self) {
+        if !self.direction {
+            self.ease_toggle();
+        }
+    }
+
+    pub fn ease_out(&mut self) {
+        if self.direction {
+            self.ease_toggle();
+        }
+    }
+
+    pub fn ease_toggle(&mut self) {
+        if self.is_active() {
+            self.time = self.duration - self.time;
+        } else if self.direction {
+            self.time = -self.out_delay;
+        } else {
+            self.time = -self.in_delay;
+        }
+
+        self.direction = !self.direction;
+    }
+
+    pub fn set_in_delay(&mut self, delay: f32) {
+        self.in_delay = delay;
+    }
+
+    pub fn set_out_delay(&mut self, delay: f32) {
+        self.out_delay = delay;
+    }
+
+    pub fn clamped(&self) -> Option<T> {
+        if self.is_active() {
+            if self.time <= 0.0 {
+                if self.direction {
+                    Some(self.from)
+                } else {
+                    Some(self.to)
+                }
+            } else {
+                None
+            }
+        } else if self.direction {
+            Some(self.to)
+        } else {
+            Some(self.from)
+        }
+    }
+}
+
+impl<F: EasingFunction> AnimationLerp<f32> for Animation<F, f32> {
+    fn lerp(&self, x: f32) -> f32 {
+        (1.0 - x) * self.from + x * self.to
+    }
+}
+
+impl<F: EasingFunction> AnimationLerp<Color> for Animation<F, Color> {
+    fn lerp(&self, x: f32) -> Color {
+        let from: glam::Vec4 = self.from.into();
+        let to: glam::Vec4 = self.to.into();
+        let lerp = (1.0 - x) * from + x * to;
+        lerp.into()
+    }
+}
+
+impl<F, T> Animation<F, T>
+where
+    F: EasingFunction,
+    T: Copy,
+    Animation<F, T>: AnimationLerp<T>,
+{
+    pub fn get(&self) -> T {
+        if let Some(clamped) = self.clamped() {
+            clamped
+        } else {
+            let x = self.time / self.duration;
+            let x = if self.direction { x } else { 1.0 - x };
+            let lerp = self.function.y(x as f64) as f32;
+            self.lerp(lerp)
+        }
+    }
+
+    pub fn ease_to(&mut self, to: T) {
+        self.from = self.get();
+        self.to = to;
+        self.time = 0.0;
+        self.direction = true;
+    }
+}

crates/sao-ui-rs/src/draw.rs

@@ -0,0 +1,352 @@
+use canary_script::Panel;
+use crate::{Color, Vec2};
+use bitflags::bitflags;
+
+pub enum Corner {
+    TopRight,
+    BottomRight,
+    BottomLeft,
+    TopLeft,
+}
+
+bitflags! {
+    pub struct CornerFlags: u8 {
+        const TOP_RIGHT = 0x01;
+        const BOTTOM_RIGHT = 0x02;
+        const BOTTOM_LEFT = 0x04;
+        const TOP_LEFT = 0x08;
+        const TOP = 0x09;
+        const RIGHT = 0x03;
+        const BOTTOM = 0x06;
+        const LEFT = 0x0C;
+        const ALL = 0x0F;
+    }
+}
+
+#[derive(Copy, Clone)]
+pub struct ColoredTriangle {
+    pub v1: Vec2,
+    pub v2: Vec2,
+    pub v3: Vec2,
+    pub color: Color,
+}
+
+#[derive(Copy, Clone)]
+pub struct Rect {
+    pub bl: Vec2,
+    pub tr: Vec2,
+}
+
+impl Rect {
+    pub fn from_xy_size(xy: Vec2, size: Vec2) -> Self {
+        Self {
+            bl: xy,
+            tr: xy + size,
+        }
+    }
+
+    pub fn from_circle_bounds(center: Vec2, radius: f32) -> Self {
+        Self {
+            bl: center - radius,
+            tr: center + radius,
+        }
+    }
+
+    pub fn from_triangle_bounds(tri: &ColoredTriangle) -> Self {
+        Self {
+            bl: tri.v1.min(tri.v2).min(tri.v3),
+            tr: tri.v1.max(tri.v2).max(tri.v3),
+        }
+    }
+
+    pub fn inset(&self, d: f32) -> Self {
+        Self {
+            bl: self.bl + d,
+            tr: self.tr - d,
+        }
+    }
+
+    pub fn tl(&self) -> Vec2 {
+        Vec2::new(self.bl.x, self.tr.y)
+    }
+
+    pub fn br(&self) -> Vec2 {
+        Vec2::new(self.tr.x, self.bl.y)
+    }
+
+    pub fn offset(&self, offset: Vec2) -> Self {
+        Self {
+            bl: self.bl + offset,
+            tr: self.tr + offset,
+        }
+    }
+
+    pub fn is_valid(&self) -> bool {
+        self.bl.cmplt(self.tr).all()
+    }
+
+    pub fn intersects_rect(&self, other: &Self) -> bool {
+        self.bl.cmple(other.tr).all() && self.tr.cmpge(other.bl).all()
+    }
+
+    pub fn intersection(&self, other: &Self) -> Option<Self> {
+        let clipped = Self {
+            bl: self.bl.max(other.bl),
+            tr: self.tr.min(other.tr),
+        };
+
+        if clipped.is_valid() {
+            Some(clipped)
+        } else {
+            None
+        }
+    }
+
+    pub fn contains_rect(&self, other: &Self) -> bool {
+        self.bl.x < other.bl.x
+            && self.bl.y < other.bl.y
+            && self.tr.x > other.tr.x
+            && self.tr.y > other.tr.y
+    }
+
+    pub fn contains_point(&self, xy: Vec2) -> bool {
+        self.bl.x < xy.x && self.bl.y < xy.y && self.tr.x > xy.x && self.tr.y > xy.y
+    }
+
+    pub fn width(&self) -> f32 {
+        self.tr.x - self.bl.x
+    }
+
+    pub fn height(&self) -> f32 {
+        self.tr.y - self.bl.y
+    }
+}
+
+pub struct DrawContext {
+    panel: Panel,
+    offset: Option<Vec2>,
+    clip_rect: Option<Rect>,
+    opacity: Option<f32>,
+}
+
+impl DrawContext {
+    pub fn new(panel: Panel) -> Self {
+        Self {
+            panel,
+            offset: None,
+            clip_rect: None,
+            opacity: None,
+        }
+    }
+
+    pub fn draw_triangle(&self, v1: Vec2, v2: Vec2, v3: Vec2, color: Color) {
+        if let Some(clip_rect) = self.clip_rect.as_ref() {
+            let tri = ColoredTriangle { v1, v2, v3, color };
+            let bb = Rect::from_triangle_bounds(&tri);
+
+            if clip_rect.contains_rect(&bb) {
+                self.draw_triangle_noclip(tri.v1, tri.v2, tri.v3, tri.color);
+            }
+        } else {
+            self.draw_triangle_noclip(v1, v2, v3, color);
+        }
+    }
+
+    fn draw_triangle_noclip(&self, mut v1: Vec2, mut v2: Vec2, mut v3: Vec2, mut color: Color) {
+        if let Some(offset) = self.offset {
+            v1 += offset;
+            v2 += offset;
+            v3 += offset;
+        }
+
+        if let Some(opacity) = self.opacity.as_ref() {
+            color.a *= opacity;
+        }
+
+        self.panel.draw_triangle(v1.into(), v2.into(), v3.into(), color);
+    }
+
+    pub fn draw_circle(&self, center: Vec2, radius: f32, color: Color) {
+        use std::f32::consts::PI;
+
+        let delta = PI / 16.0;
+        let limit = PI * 2.0 + delta;
+
+        let mut last_spoke = Vec2::new(radius + center.x, center.y);
+        let mut theta = delta;
+        while theta < limit {
+            let new_spoke = Vec2::from_angle(theta) * radius + center;
+            self.draw_triangle(center, last_spoke, new_spoke, color);
+            last_spoke = new_spoke;
+            theta += delta;
+        }
+    }
+
+    pub fn draw_quarter_circle(&self, corner: Corner, center: Vec2, radius: f32, color: Color) {
+        use std::f32::consts::{FRAC_PI_2, PI};
+
+        let spoke_num = 16.0;
+        let delta = PI / 4.0 / spoke_num;
+
+        let (mut theta, limit) = match corner {
+            Corner::TopRight => (0.0, FRAC_PI_2),
+            Corner::BottomRight => (FRAC_PI_2 * 3.0, PI * 2.0),
+            Corner::BottomLeft => (PI, FRAC_PI_2 * 3.0),
+            Corner::TopLeft => (FRAC_PI_2, PI),
+        };
+
+        let mut last_spoke = Vec2::from_angle(theta) * radius + center;
+        while theta < limit {
+            theta += delta;
+            let new_spoke = Vec2::from_angle(theta) * radius + center;
+            self.draw_triangle(center, last_spoke, new_spoke, color);
+            last_spoke = new_spoke;
+        }
+    }
+
+    pub fn draw_ring(&self, center: Vec2, radius: f32, thickness: f32, color: Color) {
+        use std::f32::consts::PI;
+
+        let delta = PI / 64.0;
+        let limit = PI * 2.0 + delta;
+
+        let mut last_spoke = glam::Vec2::new(radius + center.x, center.y);
+        let mut last_theta = 0.0;
+        let mut theta = delta;
+        while theta < limit {
+            let angle = Vec2::from_angle(theta);
+            let new_spoke = angle * radius + center;
+            let new_spoke2 = angle * (radius + thickness) + center;
+            let last_spoke2 = Vec2::from_angle(last_theta) * (radius + thickness) + center;
+
+            self.draw_triangle(new_spoke2, last_spoke, new_spoke, color);
+            self.draw_triangle(new_spoke2, last_spoke2, last_spoke, color);
+
+            last_spoke = new_spoke;
+            last_theta = theta;
+            theta += delta;
+        }
+    }
+
+    pub fn draw_rect(&self, rect: Rect, color: Color) {
+        let rect = if let Some(clip_rect) = self.clip_rect.as_ref() {
+            if let Some(clipped) = clip_rect.intersection(&rect) {
+                clipped
+            } else {
+                return;
+            }
+        } else {
+            rect
+        };
+
+        let v1 = rect.bl;
+        let v2 = Vec2::new(rect.bl.x, rect.tr.y);
+        let v3 = Vec2::new(rect.tr.x, rect.bl.y);
+        let v4 = rect.tr;
+
+        self.draw_triangle_noclip(v1, v2, v3, color);
+        self.draw_triangle_noclip(v2, v3, v4, color);
+    }
+
+    pub fn draw_rounded_rect(&self, rect: Rect, radius: f32, color: Color) {
+        self.draw_partially_rounded_rect(CornerFlags::ALL, rect, radius, color);
+    }
+
+    pub fn draw_partially_rounded_rect(
+        &self,
+        corners: CornerFlags,
+        rect: Rect,
+        radius: f32,
+        color: Color,
+    ) {
+        if corners.is_empty() {
+            self.draw_rect(rect, color);
+            return;
+        }
+
+        let mut inner_rect = rect;
+        let inset = rect.inset(radius);
+
+        if corners.intersects(CornerFlags::BOTTOM) {
+            inner_rect.bl.y += radius;
+
+            let mut bottom_edge = Rect {
+                bl: rect.bl,
+                tr: Vec2::new(rect.tr.x, rect.bl.y + radius),
+            };
+
+            if corners.contains(CornerFlags::BOTTOM_LEFT) {
+                bottom_edge.bl.x += radius;
+                self.draw_quarter_circle(Corner::BottomLeft, inset.bl, radius, color);
+            }
+
+            if corners.contains(CornerFlags::BOTTOM_RIGHT) {
+                bottom_edge.tr.x -= radius;
+                self.draw_quarter_circle(Corner::BottomRight, inset.br(), radius, color);
+            }
+
+            self.draw_rect(bottom_edge, color);
+        }
+
+        if corners.intersects(CornerFlags::TOP) {
+            inner_rect.tr.y -= radius;
+
+            let mut top_edge = Rect {
+                bl: Vec2::new(rect.bl.x, rect.tr.y - radius),
+                tr: rect.tr,
+            };
+
+            if corners.contains(CornerFlags::TOP_LEFT) {
+                top_edge.bl.x += radius;
+                self.draw_quarter_circle(Corner::TopLeft, inset.tl(), radius, color);
+            }
+
+            if corners.contains(CornerFlags::TOP_RIGHT) {
+                top_edge.tr.x -= radius;
+                self.draw_quarter_circle(Corner::TopRight, inset.tr, radius, color);
+            }
+
+            self.draw_rect(top_edge, color);
+        }
+
+        self.draw_rect(inner_rect, color);
+    }
+
+    pub fn get_clip_rect(&self) -> &Option<Rect> {
+        &self.clip_rect
+    }
+
+    pub fn with_offset(&self, offset: Vec2) -> Self {
+        Self {
+            offset: self.offset.map(|old| old + offset).or(Some(offset)),
+            clip_rect: self.clip_rect.map(|r| r.offset(-offset)),
+            ..*self
+        }
+    }
+
+    pub fn with_clip_rect(&self, mut clip_rect: Rect) -> Option<Self> {
+        if let Some(old) = self.clip_rect {
+            if let Some(clipped) = old.intersection(&clip_rect) {
+                clip_rect = clipped;
+            } else {
+                return None;
+            }
+        }
+
+        Some(Self {
+            clip_rect: Some(clip_rect),
+            ..*self
+        })
+    }
+
+    pub fn with_opacity(&self, mut opacity: f32) -> Self {
+        if let Some(old) = self.opacity {
+            opacity *= old;
+        }
+
+        Self {
+            opacity: Some(opacity),
+            ..*self
+        }
+    }
+}

crates/sao-ui-rs/src/lib.rs

@@ -0,0 +1,42 @@
+#[global_allocator]
+static ALLOC: wee_alloc::WeeAlloc = wee_alloc::WeeAlloc::INIT;
+
+pub mod anim;
+pub mod draw;
+pub mod panel;
+pub mod widgets;
+
+use canary_script::*;
+use glam::Vec2;
+use widgets::Widget;
+
+export_abi!(DummyPanel);
+
+pub struct DummyPanel {
+    panel: Panel,
+    menu: widgets::MainMenu,
+}
+
+impl BindPanel for DummyPanel {
+    fn bind(panel: Panel) -> Box<dyn PanelImpl> {
+        Box::new(Self {
+            panel,
+            menu: widgets::MainMenu::default(),
+        })
+    }
+}
+
+impl PanelImpl for DummyPanel {
+    fn update(&mut self, dt: f32) {
+        self.menu.update(dt);
+    }
+
+    fn draw(&mut self) {
+        let ctx = draw::DrawContext::new(self.panel);
+        self.menu.draw(&ctx);
+    }
+
+    fn on_cursor_event(&mut self, kind: CursorEventKind, at: canary_script::Vec2) {
+        self.menu.on_cursor_event(kind, at.into());
+    }
+}

crates/sao-ui-rs/src/panel.rs

@@ -0,0 +1 @@
+

crates/sao-ui-rs/src/widgets.rs

@@ -0,0 +1,938 @@
+use crate::anim::Animation;
+use crate::draw::{CornerFlags, DrawContext, Rect};
+use crate::{Color, CursorEventKind, Vec2};
+use keyframe::functions::*;
+
+pub trait Widget {
+    fn update(&mut self, dt: f32);
+    fn draw(&mut self, ctx: &DrawContext);
+    fn on_cursor_event(&mut self, kind: CursorEventKind, at: Vec2);
+}
+
+pub trait Button {
+    fn was_clicked(&self) -> bool;
+}
+
+pub trait FixedWidth {
+    fn get_width(&self) -> f32;
+}
+
+#[derive(Copy, Clone, Debug, Eq, PartialEq)]
+pub enum ButtonState {
+    Idle,
+    Clicking,
+    Clicked,
+    Releasing,
+}
+
+pub struct RoundButton {
+    pub pos: Vec2,
+    pub radius: f32,
+    pub spacing: f32,
+    pub thickness: f32,
+    pub shrink_anim: Animation<EaseOutQuint>,
+    pub was_clicked: bool,
+    pub state: ButtonState,
+}
+
+impl Default for RoundButton {
+    fn default() -> Self {
+        Self {
+            pos: Default::default(),
+            radius: 0.02,
+            spacing: 0.005,
+            thickness: 0.001,
+            shrink_anim: Animation::new(EaseOutQuint, 0.1, 1.0, 0.0),
+            was_clicked: false,
+            state: ButtonState::Idle,
+        }
+    }
+}
+
+impl Button for RoundButton {
+    fn was_clicked(&self) -> bool {
+        self.was_clicked
+    }
+}
+
+impl Widget for RoundButton {
+    fn update(&mut self, dt: f32) {
+        self.shrink_anim.update(dt);
+        self.was_clicked = false;
+    }
+
+    fn draw(&mut self, ctx: &DrawContext) {
+        let color = Color {
+            r: 1.0,
+            g: 1.0,
+            b: 1.0,
+            a: 1.0,
+        };
+
+        let spacing = self.shrink_anim.get() * self.spacing;
+        ctx.draw_circle(self.pos, self.radius, color);
+        ctx.draw_ring(self.pos, self.radius + spacing, self.thickness, color);
+    }
+
+    fn on_cursor_event(&mut self, kind: CursorEventKind, at: Vec2) {
+        match kind {
+            CursorEventKind::Select => {
+                if self.pos.distance(at) < self.radius {
+                    self.shrink_anim.ease_in();
+                    self.state = ButtonState::Clicked;
+                }
+            }
+            CursorEventKind::Deselect => {
+                if self.state == ButtonState::Clicked {
+                    self.shrink_anim.ease_out();
+                    self.was_clicked = true;
+                    self.state = ButtonState::Idle;
+                }
+            }
+            _ => {}
+        }
+    }
+}
+
+pub struct RectButton {
+    pub rect: Rect,
+    pub rounded_corners: CornerFlags,
+    pub radius: f32,
+    pub was_clicked: bool,
+    pub is_selected: bool,
+    pub is_hovering: bool,
+    pub color_anim: Animation<EaseInQuad, Color>,
+}
+
+impl Button for RectButton {
+    fn was_clicked(&self) -> bool {
+        self.was_clicked
+    }
+}
+
+impl RectButton {
+    pub const INACTIVE_COLOR: Color = Color::new(1., 1., 1., 0.2);
+    pub const HOVER_COLOR: Color = Color::new(1., 1., 1., 0.8);
+    pub const SELECTED_COLOR: Color = Color::new(1., 1., 0., 1.);
+
+    pub fn new(rect: Rect, rounded_corners: CornerFlags, radius: f32) -> Self {
+        Self {
+            rect,
+            rounded_corners,
+            radius,
+            was_clicked: false,
+            is_selected: false,
+            is_hovering: false,
+            color_anim: Animation::new(
+                EaseInQuad,
+                0.05,
+                Self::INACTIVE_COLOR,
+                Self::INACTIVE_COLOR,
+            ),
+        }
+    }
+}
+
+impl Widget for RectButton {
+    fn update(&mut self, dt: f32) {
+        self.was_clicked = false;
+        self.color_anim.update(dt);
+    }
+
+    fn draw(&mut self, ctx: &DrawContext) {
+        ctx.draw_partially_rounded_rect(
+            self.rounded_corners,
+            self.rect,
+            self.radius,
+            self.color_anim.get(),
+        );
+    }
+
+    fn on_cursor_event(&mut self, kind: CursorEventKind, at: Vec2) {
+        let is_on = self.rect.contains_point(at);
+
+        match kind {
+            CursorEventKind::Hover | CursorEventKind::Drag => {
+                if is_on {
+                    if !self.is_hovering && !self.is_selected {
+                        self.color_anim.ease_to(Self::HOVER_COLOR);
+                    }
+
+                    self.is_hovering = true;
+                } else {
+                    if self.is_hovering && !self.is_selected {
+                        self.color_anim.ease_to(Self::INACTIVE_COLOR);
+                    }
+
+                    self.is_hovering = false;
+                }
+            }
+            CursorEventKind::Select => {
+                if is_on {
+                    self.is_selected = true;
+                    self.color_anim.ease_to(Self::SELECTED_COLOR);
+                }
+            }
+            CursorEventKind::Deselect => {
+                if self.is_selected {
+                    self.was_clicked = true;
+                    self.is_selected = false;
+
+                    if self.is_hovering {
+                        self.color_anim.ease_to(Self::HOVER_COLOR);
+                    } else {
+                        self.color_anim.ease_to(Self::INACTIVE_COLOR);
+                    }
+                }
+            }
+        }
+    }
+}
+
+pub struct ScrollBarStyle {
+    pub margin: Vec2,
+    pub body_radius: f32,
+    pub body_width: f32,
+    pub body_idle_color: Color,
+    pub body_hover_color: Color,
+    pub body_selected_color: Color,
+    pub rail_width: f32,
+    pub rail_color: Color,
+}
+
+impl Default for ScrollBarStyle {
+    fn default() -> Self {
+        Self {
+            margin: Vec2::new(0.01, 0.01),
+            body_radius: 0.005,
+            body_width: 0.015,
+            body_idle_color: Color::new(0.5, 0.5, 0.5, 1.0),
+            body_hover_color: Color::new(0.8, 0.8, 0.8, 1.0),
+            body_selected_color: Color::new(1.0, 1.0, 0.0, 1.0),
+            rail_width: 0.005,
+            rail_color: Color::new(0.7, 0.7, 0.7, 0.5),
+        }
+    }
+}
+
+pub struct ScrollBar {
+    height: f32,
+    style: ScrollBarStyle,
+    is_dirty: bool,
+    scroll: f32,
+    content_height: f32,
+    rail_rect: Rect,
+    body_color_anim: Animation<EaseInQuad, Color>,
+    is_hovering: bool,
+    is_selected: bool,
+    grab_coord: f32,
+    grab_scroll: f32,
+}
+
+impl ScrollBar {
+    pub fn new(height: f32, content_height: f32, style: ScrollBarStyle) -> Self {
+        let center_x = style.body_width / 2.0 + style.margin.x;
+        let rail_rect = Rect {
+            bl: Vec2::new(center_x - style.rail_width / 2.0, style.margin.y),
+            tr: Vec2::new(center_x + style.rail_width / 2.0, height - style.margin.y),
+        };
+
+        let body_color_anim = Animation::new(
+            EaseInQuad,
+            0.05,
+            style.body_idle_color,
+            style.body_idle_color,
+        );
+
+        Self {
+            height,
+            style,
+            is_dirty: true,
+            scroll: 0.0,
+            content_height,
+            rail_rect,
+            body_color_anim,
+            is_hovering: false,
+            is_selected: false,
+            grab_coord: 0.0,
+            grab_scroll: 0.0,
+        }
+    }
+
+    pub fn get_body_rect(&self) -> Rect {
+        let style = &self.style;
+        let rail_height = self.rail_rect.height();
+        let body_height = (self.height / self.content_height) * rail_height;
+        let body_y = rail_height - (self.scroll / self.content_height) * rail_height - body_height;
+        let body_xy = Vec2::new(style.margin.x, body_y + style.margin.y);
+        let body_size = Vec2::new(style.body_width, body_height);
+        Rect::from_xy_size(body_xy, body_size)
+    }
+
+    pub fn is_dirty(&self) -> bool {
+        self.is_dirty
+    }
+
+    pub fn get_scroll(&self) -> f32 {
+        self.scroll
+    }
+}
+
+impl Widget for ScrollBar {
+    fn update(&mut self, dt: f32) {
+        self.is_dirty = false;
+        self.body_color_anim.update(dt);
+    }
+
+    fn draw(&mut self, ctx: &DrawContext) {
+        let style = &self.style;
+        let body_rect = self.get_body_rect();
+        ctx.draw_rect(self.rail_rect, style.rail_color);
+        ctx.draw_rounded_rect(body_rect, style.body_radius, self.body_color_anim.get());
+    }
+
+    fn on_cursor_event(&mut self, kind: CursorEventKind, at: Vec2) {
+        let is_on = self.get_body_rect().contains_point(at);
+
+        match kind {
+            CursorEventKind::Hover | CursorEventKind::Drag => {
+                if is_on {
+                    if !self.is_hovering && !self.is_selected {
+                        self.body_color_anim.ease_to(self.style.body_hover_color);
+                    }
+
+                    self.is_hovering = true;
+                } else {
+                    if self.is_hovering && !self.is_selected {
+                        self.body_color_anim.ease_to(self.style.body_idle_color);
+                    }
+
+                    self.is_hovering = false;
+                }
+
+                if kind == CursorEventKind::Drag && self.is_selected {
+                    self.scroll = ((self.grab_coord - at.y) / self.rail_rect.height())
+                        * self.content_height
+                        + self.grab_scroll;
+
+                    let scroll_cap = self.content_height - self.height;
+                    if self.scroll > scroll_cap {
+                        self.scroll = scroll_cap;
+                    } else if self.scroll < 0.0 {
+                        self.scroll = 0.0;
+                    }
+
+                    self.is_dirty = true;
+                }
+            }
+            CursorEventKind::Select => {
+                if is_on {
+                    self.is_selected = true;
+                    self.body_color_anim.ease_to(self.style.body_selected_color);
+                    self.grab_coord = at.y;
+                    self.grab_scroll = self.scroll;
+                }
+            }
+            CursorEventKind::Deselect => {
+                if self.is_selected {
+                    self.is_selected = false;
+
+                    if self.is_hovering {
+                        self.body_color_anim.ease_to(self.style.body_hover_color);
+                    } else {
+                        self.body_color_anim.ease_to(self.style.body_idle_color);
+                    }
+                }
+            }
+        }
+    }
+}
+
+pub struct ScrollView<T> {
+    inner: Offset<T>,
+    scroll_bar: Offset<ScrollBar>,
+    clip_rect: Rect,
+    height: f32,
+    content_height: f32,
+}
+
+impl<T: Widget> ScrollView<T> {
+    pub fn new(
+        bar_style: ScrollBarStyle,
+        width: f32,
+        height: f32,
+        inner_cb: impl FnOnce(f32) -> (T, f32),
+    ) -> Self {
+        let content_width = width - bar_style.body_width - bar_style.margin.x * 2.0;
+        let (inner, content_height) = inner_cb(content_width);
+        let inner = Offset::new(inner, Vec2::ZERO);
+
+        let scroll_bar_offset = Vec2::new(content_width, 0.0);
+        let scroll_bar = ScrollBar::new(height, content_height, bar_style);
+        let scroll_bar = Offset::new(scroll_bar, scroll_bar_offset);
+
+        let clip_rect = Rect::from_xy_size(Vec2::ZERO, Vec2::new(content_width, height));
+
+        Self {
+            inner,
+            scroll_bar,
+            clip_rect,
+            content_height,
+            height,
+        }
+    }
+}
+
+impl<T: Widget> Widget for ScrollView<T> {
+    fn update(&mut self, dt: f32) {
+        if self.scroll_bar.inner.is_dirty() {
+            let yoff = self.scroll_bar.inner.get_scroll() - self.content_height + self.height;
+            self.inner.set_offset(Vec2::new(0.0, yoff));
+        }
+
+        self.inner.update(dt);
+        self.scroll_bar.update(dt);
+    }
+
+    fn draw(&mut self, ctx: &DrawContext) {
+        self.scroll_bar.draw(ctx);
+
+        if let Some(ctx) = ctx.with_clip_rect(self.clip_rect) {
+            self.inner.draw(&ctx);
+        }
+    }
+
+    fn on_cursor_event(&mut self, kind: CursorEventKind, at: Vec2) {
+        self.inner.on_cursor_event(kind, at);
+        self.scroll_bar.on_cursor_event(kind, at);
+    }
+}
+
+#[derive(Eq, PartialEq)]
+pub enum ScrollMenuState {
+    Opening,
+    Idle,
+    Scrolling,
+    Closing,
+    Closed,
+}
+
+#[derive(Copy, Clone, Eq, PartialEq)]
+pub enum ScrollMenuEvent {
+    None,
+    SubmenuOpen(usize),
+    SubmenuClose(usize),
+}
+
+pub struct ScrollMenuButton<T> {
+    pub widget: T,
+    pub slide_anim: Animation<EaseOut>,
+    pub opacity_anim: Animation<EaseOut>,
+}
+
+pub struct ScrollMenu<T> {
+    pub buttons: Vec<ScrollMenuButton<T>>,
+    pub spacing: f32,
+    pub scroll_anim: Animation<EaseInOutQuint>,
+    pub state: ScrollMenuState,
+    pub selected: usize,
+    pub was_clicked: Option<usize>,
+    pub event: ScrollMenuEvent,
+}
+
+impl<T> ScrollMenu<T> {
+    pub fn new(buttons: Vec<T>, spacing: f32) -> Self {
+        let inter_button_delay = 0.05;
+        let max_delay = buttons.len() as f32 * inter_button_delay;
+
+        let buttons: Vec<_> = buttons
+            .into_iter()
+            .enumerate()
+            .map(|(i, widget)| {
+                let duration = 0.25;
+                let out_delay = i as f32 * inter_button_delay;
+                let in_delay = max_delay - out_delay;
+
+                let mut slide_anim = Animation::new(EaseOut, duration, 0.25, 0.0);
+                slide_anim.set_in_delay(in_delay);
+                slide_anim.set_out_delay(out_delay);
+                slide_anim.ease_in();
+
+                let mut opacity_anim = Animation::new(EaseOut, duration, 0.0, 1.0);
+                opacity_anim.set_in_delay(in_delay);
+                opacity_anim.set_out_delay(out_delay);
+                opacity_anim.ease_in();
+
+                ScrollMenuButton {
+                    widget,
+                    slide_anim,
+                    opacity_anim,
+                }
+            })
+            .collect();
+
+        Self {
+            buttons,
+            spacing,
+            scroll_anim: Animation::new(EaseInOutQuint, 0.25, 0.0, 0.0),
+            state: ScrollMenuState::Opening,
+            selected: 0,
+            was_clicked: None,
+            event: ScrollMenuEvent::None,
+        }
+    }
+
+    pub fn get_event(&self) -> ScrollMenuEvent {
+        self.event
+    }
+
+    pub fn get_was_clicked(&self) -> Option<usize> {
+        self.was_clicked
+    }
+
+    pub fn select(&mut self, button_id: usize) {
+        self.scroll_anim.ease_to(button_id as f32);
+        self.state = ScrollMenuState::Scrolling;
+        self.event = ScrollMenuEvent::SubmenuClose(self.selected);
+        self.selected = button_id;
+    }
+
+    pub fn close(&mut self) {
+        self.state = ScrollMenuState::Closing;
+        self.event = ScrollMenuEvent::SubmenuClose(self.selected);
+
+        for button in self.buttons.iter_mut() {
+            button.slide_anim.ease_out();
+            button.opacity_anim.ease_out();
+        }
+    }
+
+    pub fn for_buttons(&mut self, mut cb: impl FnMut(&mut ScrollMenuButton<T>, usize, f32)) {
+        for (i, button) in self.buttons.iter_mut().enumerate() {
+            let y = -(i as f32 - self.scroll_anim.get()) * self.spacing + button.slide_anim.get();
+            cb(button, i, y);
+        }
+    }
+
+    fn animate_buttons(&mut self, dt: f32) -> bool {
+        let mut all_slid = true;
+
+        self.for_buttons(|button, _i, _y| {
+            button.slide_anim.update(dt);
+            button.opacity_anim.update(dt);
+
+            if button.slide_anim.is_active() {
+                all_slid = false;
+            }
+        });
+
+        all_slid
+    }
+}
+
+impl<T: Widget + Button> Widget for ScrollMenu<T> {
+    fn update(&mut self, dt: f32) {
+        self.event = ScrollMenuEvent::None;
+        self.was_clicked = None;
+
+        match self.state {
+            ScrollMenuState::Opening => {
+                if self.animate_buttons(dt) {
+                    self.state = ScrollMenuState::Idle;
+                    self.event = ScrollMenuEvent::SubmenuOpen(self.selected);
+                }
+            }
+            ScrollMenuState::Idle => {}
+            ScrollMenuState::Scrolling => {
+                self.for_buttons(|button, _i, _y| {
+                    button.widget.update(dt);
+                });
+
+                self.scroll_anim.update(dt);
+
+                if !self.scroll_anim.is_active() {
+                    self.state = ScrollMenuState::Idle;
+                    self.event = ScrollMenuEvent::SubmenuOpen(self.selected);
+                }
+            }
+            ScrollMenuState::Closing => {
+                if self.animate_buttons(dt) {
+                    self.state = ScrollMenuState::Closed;
+                }
+            }
+            ScrollMenuState::Closed => {
+                return;
+            }
+        }
+
+        self.for_buttons(|button, _i, _y| {
+            button.widget.update(dt);
+        });
+    }
+
+    fn draw(&mut self, ctx: &DrawContext) {
+        if self.state == ScrollMenuState::Closed {
+            return;
+        }
+
+        self.for_buttons(|button, _i, y| {
+            let ctx = ctx.with_offset(Vec2::new(0.0, y));
+
+            let opacity = button.opacity_anim.get();
+            let ctx = if opacity != 1.0 {
+                ctx.with_opacity(opacity)
+            } else {
+                ctx
+            };
+
+            button.widget.draw(&ctx);
+        })
+    }
+
+    fn on_cursor_event(&mut self, kind: CursorEventKind, at: Vec2) {
+        if self.state != ScrollMenuState::Idle {
+            return;
+        }
+
+        let mut was_clicked = None;
+
+        self.for_buttons(|button, i, y| {
+            let at = at - Vec2::new(0.0, y);
+            button.widget.on_cursor_event(kind, at);
+
+            if button.widget.was_clicked() {
+                was_clicked = Some(i);
+            }
+        });
+
+        if let Some(clicked) = was_clicked {
+            if clicked != self.selected {
+                self.was_clicked = Some(clicked);
+            }
+        }
+    }
+}
+
+pub struct Offset<T> {
+    inner: T,
+    offset: Vec2,
+}
+
+impl<T: Widget> Offset<T> {
+    pub fn new(inner: T, offset: Vec2) -> Self {
+        Self { inner, offset }
+    }
+
+    pub fn set_offset(&mut self, offset: Vec2) {
+        self.offset = offset;
+    }
+}
+
+impl<T: Widget> Widget for Offset<T> {
+    fn update(&mut self, dt: f32) {
+        self.inner.update(dt);
+    }
+
+    fn draw(&mut self, ctx: &DrawContext) {
+        let ctx = ctx.with_offset(self.offset);
+        self.inner.draw(&ctx);
+    }
+
+    fn on_cursor_event(&mut self, kind: CursorEventKind, at: Vec2) {
+        let at = at - self.offset;
+        self.inner.on_cursor_event(kind, at);
+    }
+}
+
+pub struct Reveal<T> {
+    inner: T,
+    slide_anim: Animation<EaseIn>,
+    opacity_anim: Animation<Linear>,
+    state: bool,
+}
+
+impl<T: Widget> Reveal<T> {
+    pub fn new(inner: T, slide: f32, duration: f32) -> Self {
+        Self {
+            inner,
+            slide_anim: Animation::new(EaseIn, duration, slide, 0.0),
+            opacity_anim: Animation::new(Linear, duration, 0.0, 1.0),
+            state: false,
+        }
+    }
+
+    pub fn get_offset(&self) -> Vec2 {
+        Vec2::new(self.slide_anim.get(), 0.0)
+    }
+
+    pub fn show(&mut self) {
+        self.state = true;
+        self.slide_anim.ease_in();
+        self.opacity_anim.ease_in();
+    }
+
+    pub fn hide(&mut self) {
+        self.state = false;
+        self.slide_anim.ease_out();
+        self.opacity_anim.ease_out();
+    }
+}
+
+impl<T: Widget> Widget for Reveal<T> {
+    fn update(&mut self, dt: f32) {
+        self.slide_anim.update(dt);
+        self.opacity_anim.update(dt);
+        self.inner.update(dt);
+    }
+
+    fn draw(&mut self, ctx: &DrawContext) {
+        let ctx = ctx.with_offset(Vec2::new(self.slide_anim.get(), 0.0));
+        let ctx = if self.opacity_anim.is_active() {
+            ctx.with_opacity(self.opacity_anim.get())
+        } else if self.state {
+            ctx
+        } else {
+            return;
+        };
+
+        self.inner.draw(&ctx);
+    }
+
+    fn on_cursor_event(&mut self, kind: CursorEventKind, mut at: Vec2) {
+        if !self.state || self.opacity_anim.is_active() {
+            return;
+        }
+
+        at -= Vec2::new(self.slide_anim.get(), 0.0);
+        self.inner.on_cursor_event(kind, at);
+    }
+}
+
+pub struct MainMenu {
+    pub menu: ScrollMenu<RoundButton>,
+    pub inventory: Reveal<Offset<TabMenu>>,
+}
+
+impl MainMenu {
+    pub const SUBMENU_SPACING: f32 = 0.05;
+}
+
+impl Default for MainMenu {
+    fn default() -> Self {
+        let mut buttons = Vec::new();
+        for _ in 0..5 {
+            let button = RoundButton::default();
+            buttons.push(button);
+        }
+
+        let inventory = TabMenu::new();
+        let inventory = Offset::new(inventory, Vec2::new(Self::SUBMENU_SPACING, 0.0));
+        let inventory = Reveal::new(inventory, -0.02, 0.1);
+
+        Self {
+            menu: ScrollMenu::new(buttons, 0.1),
+            inventory,
+        }
+    }
+}
+
+impl Widget for MainMenu {
+    fn update(&mut self, dt: f32) {
+        match self.menu.get_was_clicked() {
+            None => {}
+            Some(4) => self.menu.close(),
+            Some(button) => self.menu.select(button),
+        };
+
+        match self.menu.get_event() {
+            ScrollMenuEvent::SubmenuOpen(0) => self.inventory.show(),
+            ScrollMenuEvent::SubmenuClose(0) => self.inventory.hide(),
+            _ => {}
+        };
+
+        self.menu.update(dt);
+        self.inventory.update(dt);
+    }
+
+    fn draw(&mut self, ctx: &DrawContext) {
+        self.menu.draw(&ctx);
+        self.inventory.draw(&ctx);
+    }
+
+    fn on_cursor_event(&mut self, kind: CursorEventKind, at: Vec2) {
+        self.menu.on_cursor_event(kind, at);
+        self.inventory.on_cursor_event(kind, at);
+    }
+}
+
+pub struct TabMenu {
+    tabs: Vec<RectButton>,
+    view: Offset<ScrollView<Inventory>>,
+    head_rect: Rect,
+    separator_rect: Rect,
+}
+
+impl TabMenu {
+    const HEAD_RADIUS: f32 = 0.025;
+    const HEAD_HEIGHT: f32 = 0.03;
+    const TAB_WIDTH: f32 = 0.04;
+    const TAB_HEIGHT: f32 = 0.06;
+    const TAB_NUM: usize = 6;
+    const SEPARATOR_WIDTH: f32 = 0.015;
+    const INNER_RADIUS: f32 = 0.005;
+    const CONTENT_WIDTH: f32 = 0.4;
+
+    pub fn new() -> Self {
+        let tab_size = Vec2::new(Self::TAB_WIDTH, Self::TAB_HEIGHT);
+
+        let mut tabs = Vec::new();
+        for i in 0..Self::TAB_NUM {
+            let y = (i + 1) as f32 * Self::TAB_HEIGHT;
+            let pos = Vec2::new(0.0, -y);
+            let radius = Self::HEAD_RADIUS;
+
+            let corners = if i == Self::TAB_NUM - 1 {
+                CornerFlags::BOTTOM_LEFT
+            } else {
+                CornerFlags::empty()
+            };
+
+            let rect = Rect::from_xy_size(pos, tab_size);
+            tabs.push(RectButton::new(rect, corners, radius));
+        }
+
+        let tab_list_height = Self::TAB_NUM as f32 * Self::TAB_HEIGHT;
+
+        let scroll_bar = ScrollBar::new(tab_list_height, tab_list_height * 3.0, Default::default());
+        let scroll_x = Self::TAB_WIDTH + Self::SEPARATOR_WIDTH + Self::CONTENT_WIDTH;
+        let scroll_bar = Offset::new(scroll_bar, Vec2::new(scroll_x, -tab_list_height));
+
+        let separator_rect = Rect {
+            bl: Vec2::new(Self::TAB_WIDTH, -tab_list_height),
+            tr: Vec2::new(Self::TAB_WIDTH + Self::SEPARATOR_WIDTH, 0.0),
+        };
+
+        let head_width = Self::TAB_WIDTH
+            + Self::SEPARATOR_WIDTH
+            + Self::CONTENT_WIDTH
+            + scroll_bar.inner.style.body_width
+            + scroll_bar.inner.style.margin.x * 2.0;
+
+        let head_rect = Rect {
+            bl: Vec2::ZERO,
+            tr: Vec2::new(head_width, Self::HEAD_HEIGHT),
+        };
+
+        let view_rect = Rect {
+            bl: Vec2::new(Self::TAB_WIDTH + Self::SEPARATOR_WIDTH, -tab_list_height),
+            tr: Vec2::new(head_rect.tr.x, 0.0),
+        };
+
+        let view = ScrollView::new(
+            Default::default(),
+            view_rect.width(),
+            view_rect.height(),
+            |available_width: f32| Inventory::new(available_width),
+        );
+
+        let view = Offset::new(view, view_rect.bl);
+
+        Self {
+            tabs,
+            view,
+            separator_rect,
+            head_rect,
+        }
+    }
+}
+
+impl Widget for TabMenu {
+    fn update(&mut self, dt: f32) {
+        for tab in self.tabs.iter_mut() {
+            tab.update(dt);
+        }
+
+        self.view.update(dt);
+    }
+
+    fn draw(&mut self, ctx: &DrawContext) {
+        for tab in self.tabs.iter_mut() {
+            tab.draw(ctx);
+        }
+
+        let head_color = Color {
+            r: 1.0,
+            g: 1.0,
+            b: 1.0,
+            a: 1.0,
+        };
+
+        // draw shapes
+        ctx.draw_partially_rounded_rect(
+            CornerFlags::BOTTOM_RIGHT,
+            self.separator_rect,
+            Self::INNER_RADIUS,
+            head_color,
+        );
+
+        ctx.draw_partially_rounded_rect(
+            CornerFlags::TOP_LEFT | CornerFlags::TOP_RIGHT,
+            self.head_rect,
+            Self::HEAD_RADIUS,
+            head_color,
+        );
+
+        self.view.draw(ctx);
+    }
+
+    fn on_cursor_event(&mut self, kind: CursorEventKind, at: Vec2) {
+        for tab in self.tabs.iter_mut() {
+            tab.on_cursor_event(kind, at);
+        }
+
+        self.view.on_cursor_event(kind, at);
+    }
+}
+
+pub struct Inventory {
+    width: f32,
+    height: f32,
+}
+
+impl Inventory {
+    pub fn new(available_width: f32) -> (Self, f32) {
+        let height = 1.5;
+
+        (
+            Self {
+                width: available_width,
+                height,
+            },
+            height,
+        )
+    }
+}
+
+impl Widget for Inventory {
+    fn update(&mut self, dt: f32) {}
+
+    fn draw(&mut self, ctx: &DrawContext) {
+        let box_size = 0.04;
+        let box_margin = 0.01;
+        let box_stride = box_size + box_margin;
+
+        let grid_width = (self.width / box_stride).floor() as usize;
+        let grid_height = (self.height / box_stride).floor() as usize;
+
+        for x in 0..grid_width {
+            for y in 0..grid_height {
+                let off = Vec2::new(x as f32, y as f32) * box_stride;
+                let rect = Rect::from_xy_size(off, Vec2::new(box_size, box_size));
+                let color = Color::MAGENTA;
+                ctx.draw_rect(rect, color);
+            }
+        }
+    }
+
+    fn on_cursor_event(&mut self, kind: CursorEventKind, at: Vec2) {}
+}

crates/script/Cargo.toml

@@ -0,0 +1,10 @@
+[package]
+name = "canary_script"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]
+canary_types = { path = "../types" }
+
+[features]
+glam = ["canary_types/glam"]

crates/script/src/lib.rs

@@ -0,0 +1,110 @@
+pub use canary_types::*;
+
+#[macro_export]
+macro_rules! export_abi {
+    ($panel_impl: ident) => {
+        #[no_mangle]
+        pub extern "C" fn bind_panel(panel: u32) -> u32 {
+            ::canary_script::abi::bind_panel::<$panel_impl>(panel)
+        }
+
+        #[no_mangle]
+        pub extern "C" fn update(dt: f32) {
+            ::canary_script::abi::update(dt)
+        }
+
+        #[no_mangle]
+        pub extern "C" fn draw() {
+            ::canary_script::abi::draw()
+        }
+
+        #[no_mangle]
+        pub extern "C" fn on_cursor_event(kind: u32, x: f32, y: f32) {
+            ::canary_script::abi::on_cursor_event(kind, x, y)
+        }
+    };
+}
+
+pub mod abi {
+    use super::*;
+    use num_traits::FromPrimitive;
+
+    static mut PANEL_IMPLS: Vec<Box<dyn PanelImpl>> = Vec::new();
+
+    pub fn bind_panel<T: BindPanel>(panel: u32) -> u32 {
+        unsafe {
+            let panel = Panel(panel);
+            let panel_impl = T::bind(panel);
+            let id = PANEL_IMPLS.len() as u32;
+            PANEL_IMPLS.push(panel_impl);
+            id
+        }
+    }
+
+    pub fn update(dt: f32) {
+        unsafe {
+            for panel in PANEL_IMPLS.iter_mut() {
+                panel.update(dt);
+            }
+        }
+    }
+
+    pub fn draw() {
+        unsafe {
+            for panel in PANEL_IMPLS.iter_mut() {
+                panel.draw();
+            }
+        }
+    }
+
+    pub fn on_cursor_event(kind: u32, x: f32, y: f32) {
+        let panel = unsafe { &mut PANEL_IMPLS[0] };
+        let at = canary_types::Vec2 { x, y };
+        let kind = CursorEventKind::from_u32(kind).unwrap();
+        panel.on_cursor_event(kind, at);
+    }
+}
+
+pub trait BindPanel {
+    fn bind(panel: Panel) -> Box<dyn PanelImpl>;
+}
+
+pub trait PanelImpl {
+    fn update(&mut self, dt: f32);
+    fn draw(&mut self);
+    fn on_cursor_event(&mut self, kind: CursorEventKind, at: Vec2);
+}
+
+#[repr(transparent)]
+#[derive(Copy, Clone)]
+pub struct Panel(u32);
+
+impl Panel {
+    pub unsafe fn bind(id: u32) -> Self {
+        Self(id)
+    }
+
+    pub fn draw_triangle(&self, v1: Vec2, v2: Vec2, v3: Vec2, color: Color) {
+        unsafe {
+            UiPanel_drawTriangle(
+                self.0, v1.x, v1.y, v2.x, v2.y, v3.x, v3.y, color.r, color.g, color.b, color.a,
+            )
+        }
+    }
+}
+
+extern "C" {
+    fn UiPanel_drawTriangle(
+        panel: u32,
+        x1: f32,
+        y1: f32,
+        x2: f32,
+        y2: f32,
+        x3: f32,
+        y3: f32,
+        r: f32,
+        g: f32,
+        b: f32,
+        a: f32,
+    );
+}

crates/types/Cargo.toml

@@ -0,0 +1,10 @@
+[package]
+name = "canary_types"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]
+bytemuck = { version = "1", features = ["derive"] }
+glam = { version = "^0.21", optional = true }
+num-derive = "0.3"
+num-traits = "0.2"

crates/types/src/lib.rs

@@ -0,0 +1,89 @@
+#[macro_use]
+extern crate num_derive;
+
+pub use num_traits;
+use bytemuck::{Pod, Zeroable};
+
+#[repr(C)]
+#[derive(Copy, Clone, Debug, Pod, Zeroable)]
+pub struct Vec2 {
+    pub x: f32,
+    pub y: f32,
+}
+
+#[repr(C)]
+#[derive(Copy, Clone, Debug, Pod, Zeroable)]
+pub struct Color {
+    pub r: f32,
+    pub g: f32,
+    pub b: f32,
+    pub a: f32,
+}
+
+impl Color {
+    pub const WHITE: Self = Self::new(1., 1., 1., 1.);
+    pub const BLACK: Self = Self::new(0., 0., 0., 1.);
+    pub const TRANSPARENT: Self = Self::new(0., 0., 0., 0.);
+    pub const RED: Self = Self::new(1., 0., 0., 1.);
+    pub const GREEN: Self = Self::new(1., 0., 0., 1.);
+    pub const BLUE: Self = Self::new(0., 1., 0., 1.);
+    pub const YELLOW: Self = Self::new(1., 1., 0., 1.);
+    pub const MAGENTA: Self = Self::new(1., 0., 1., 1.);
+    pub const CYAN: Self = Self::new(0., 1., 1., 1.);
+
+    pub const fn new(r: f32, g: f32, b: f32, a: f32) -> Self {
+        Self { r, g, b, a }
+    }
+
+    pub fn to_rgba_unmultiplied(&self) -> (u8, u8, u8, u8) {
+        let map = |c: f32| (c * 255.0).floor() as u8;
+        (map(self.r), map(self.g), map(self.b), map(self.a))
+    }
+}
+
+#[repr(C)]
+#[derive(Copy, Clone, Debug, Pod, Zeroable)]
+pub struct MeshVertex {
+    pub position: Vec2,
+    pub color: Color,
+}
+
+pub type MeshIndex = u32;
+
+#[derive(Copy, Clone, Debug, Eq, PartialEq, FromPrimitive, ToPrimitive)]
+pub enum CursorEventKind {
+    Hover = 0,
+    Select = 1,
+    Drag = 2,
+    Deselect = 3,
+}
+
+#[cfg(feature = "glam")]
+mod glam_interop {
+    use super::*;
+
+    impl From<glam::Vec2> for Vec2 {
+        fn from(other: glam::Vec2) -> Self {
+            Self { x: other.x, y: other.y }
+        }
+    }
+
+    impl From<Vec2> for glam::Vec2 {
+        fn from(other: Vec2) -> Self {
+            Self::new(other.x, other.y)
+        }
+    }
+
+    impl From<glam::Vec4> for Color {
+        fn from(other: glam::Vec4) -> Self {
+            Self::new(other.x, other.y, other.z, other.w)
+        }
+    }
+
+    impl From<Color> for glam::Vec4 {
+        fn from(other: Color) -> Self {
+            let Color { r, g, b, a } = other;
+            Self::new(r, g, b, a)
+        }
+    }
+}

src/lib.rs

@@ -0,0 +1,201 @@
+pub use canary_types::*;
+use parking_lot::Mutex;
+
+/// Low-level script API callbacks.
+pub trait ScriptAbi {
+    fn start_draw(&self);
+    fn draw_indexed(&self, vertices: &[MeshVertex], indices: &[MeshIndex]);
+    fn with_draw_commands(&self, f: impl FnOnce(&[DrawCommand]));
+}
+
+pub trait ScriptInstance {
+    fn update(&mut self, dt: f32);
+    fn draw(&mut self, f: impl FnOnce(&[DrawCommand]));
+    fn on_cursor_event(&mut self, kind: CursorEventKind, at: Vec2);
+}
+
+#[non_exhaustive]
+pub enum DrawCommand {
+    Mesh {
+        vertices: Vec<MeshVertex>,
+        indices: Vec<MeshIndex>,
+    },
+}
+
+pub struct WasmtimeRuntime {
+    engine: wasmtime::Engine,
+}
+
+impl WasmtimeRuntime {
+    pub fn new() -> anyhow::Result<Self> {
+        let mut config = wasmtime::Config::new();
+        config.wasm_simd(true);
+        config.wasm_bulk_memory(true);
+        config.cranelift_opt_level(wasmtime::OptLevel::Speed);
+
+        let engine = wasmtime::Engine::new(&config)?;
+
+        Ok(Self { engine })
+    }
+
+    pub fn load_module<T: ScriptAbi>(
+        &self,
+        abi: T,
+        module: &[u8],
+    ) -> anyhow::Result<WasmtimeScript<T>> {
+        let module = wasmtime::Module::new(&self.engine, module)?;
+        let mut store = wasmtime::Store::new(&self.engine, abi);
+        let mut linker = wasmtime::Linker::new(&self.engine);
+        WasmtimeScript::link(&mut linker)?;
+        let instance = linker.instantiate(&mut store, &module)?;
+        let update = instance.get_typed_func(&mut store, "update")?;
+        let draw = instance.get_typed_func(&mut store, "draw")?;
+        let on_cursor_event = instance.get_typed_func(&mut store, "on_cursor_event")?;
+
+        let bind_panel = instance.get_typed_func::<u32, u32, _>(&mut store, "bind_panel")?;
+        bind_panel.call(&mut store, 0u32)?;
+
+        Ok(WasmtimeScript {
+            store,
+            update,
+            draw,
+            on_cursor_event,
+        })
+    }
+}
+
+pub struct WasmtimeScript<T> {
+    store: wasmtime::Store<T>,
+    update: wasmtime::TypedFunc<f32, ()>,
+    draw: wasmtime::TypedFunc<(), ()>,
+    on_cursor_event: wasmtime::TypedFunc<(u32, f32, f32), ()>,
+}
+
+impl<T: ScriptAbi> WasmtimeScript<T> {
+    pub fn link(linker: &mut wasmtime::Linker<T>) -> anyhow::Result<()> {
+        let module = "env";
+
+        linker.func_wrap(
+            module,
+            "draw_indexed",
+            |mut caller: wasmtime::Caller<'_, T>,
+             vertices_ptr: u32,
+             vertices_num: u32,
+             indices_ptr: u32,
+             indices_num: u32| {
+                let vertices = Self::get_memory_slice(&mut caller, vertices_ptr, vertices_num);
+                let indices = Self::get_memory_slice(&mut caller, indices_ptr, indices_num);
+                caller.data().draw_indexed(vertices, indices);
+            },
+        )?;
+
+        linker.func_wrap(
+            module,
+            "UiPanel_drawTriangle",
+            |caller: wasmtime::Caller<'_, T>,
+             _panel: u32,
+             x1: f32,
+             y1: f32,
+             x2: f32,
+             y2: f32,
+             x3: f32,
+             y3: f32,
+             r: f32,
+             g: f32,
+             b: f32,
+             a: f32| {
+                let v1 = Vec2 { x: x1, y: y1 };
+                let v2 = Vec2 { x: x2, y: y2 };
+                let v3 = Vec2 { x: x3, y: y3 };
+                let color = Color { r, g, b, a };
+
+                let vertices = [
+                    MeshVertex {
+                        position: v1,
+                        color,
+                    },
+                    MeshVertex {
+                        position: v2,
+                        color,
+                    },
+                    MeshVertex {
+                        position: v3,
+                        color,
+                    },
+                ];
+
+                let indices = [0, 1, 2];
+
+                caller.data().draw_indexed(&vertices, &indices);
+            },
+        )?;
+
+        Ok(())
+    }
+
+    fn get_memory_slice<D: bytemuck::Pod>(
+        caller: &mut wasmtime::Caller<'_, T>,
+        ptr: u32,
+        num: u32,
+    ) -> &'static [D] {
+        let len = num as usize * std::mem::size_of::<D>();
+        let bytes = Self::get_memory_slice_bytes(caller, ptr as usize, len);
+        bytemuck::cast_slice(bytes)
+    }
+
+    fn get_memory_slice_bytes(
+        caller: &mut wasmtime::Caller<'_, T>,
+        ptr: usize,
+        len: usize,
+    ) -> &'static [u8] {
+        let memory = caller.get_export("memory").unwrap().into_memory().unwrap();
+        if ptr + len > memory.data_size(&caller) {
+            panic!("Attempted wasm memory read is out-of-bounds!");
+        }
+
+        unsafe {
+            let ptr = memory.data_ptr(caller).add(ptr);
+            std::slice::from_raw_parts(ptr, len)
+        }
+    }
+}
+
+impl<T: ScriptAbi> ScriptInstance for WasmtimeScript<T> {
+    fn update(&mut self, dt: f32) {
+        self.update.call(&mut self.store, dt).unwrap();
+    }
+
+    fn draw(&mut self, f: impl FnOnce(&[DrawCommand])) {
+        self.store.data().start_draw();
+        self.draw.call(&mut self.store, ()).unwrap();
+        self.store.data().with_draw_commands(f);
+    }
+
+    fn on_cursor_event(&mut self, kind: CursorEventKind, at: Vec2) {
+        self.on_cursor_event
+            .call(&mut self.store, (kind as u32, at.x, at.y))
+            .unwrap();
+    }
+}
+
+#[derive(Default)]
+pub struct SimpleScriptAbi {
+    draw_cmds: Mutex<Vec<DrawCommand>>,
+}
+
+impl ScriptAbi for SimpleScriptAbi {
+    fn start_draw(&self) {
+        self.draw_cmds.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 with_draw_commands(&self, f: impl FnOnce(&[DrawCommand])) {
+        f(self.draw_cmds.lock().as_slice());
+    }
+}