@downdraft/engine 0.0.0 → 0.1.1

package/libraries/blitz-ui/native/src/fonts.rs

@@ -0,0 +1,20 @@
+//! Font setup. WASM has no system font collection, so we embed DejaVu Sans
+//! via blitz-dom's `build_single_font_ctx` (decodes WOFF2 and registers it as
+//! the fallback for every generic family), plus blitz-dom's bullet font.
+//! Games can override via `ShellConfig::font`.
+
+use std::sync::Arc;
+
+use blitz_dom::FontContext;
+use linebender_resource_handle::Blob;
+
+const FONT_BYTES: &[u8] = include_bytes!("../assets/DejaVuSans.woff2");
+
+pub fn font_ctx(custom: Option<&'static [u8]>) -> FontContext {
+    let mut ctx = blitz_dom::build_single_font_ctx(custom.unwrap_or(FONT_BYTES));
+    // blitz-dom's default font_ctx also registers the bullet font used for
+    // list markers; keep parity since we replace the default ctx entirely.
+    ctx.collection
+        .register_fonts(Blob::new(Arc::new(blitz_dom::BULLET_FONT) as _), None);
+    ctx
+}

package/libraries/blitz-ui/native/src/input.rs

@@ -0,0 +1,80 @@
+//! Input events injected from JS. The host pushes `PendingInput`s onto the
+//! bridge queue; the shell drains them inside `ui_tick` where it can reach
+//! the document.
+//!
+//! Coordinates arrive in canvas *backing* pixels (the engine's InputManager
+//! already converts DOM client coords to canvas space). We convert to the
+//! document's logical/CSS pixel space using the viewport scale when
+//! dispatching.
+
+use std::str::FromStr;
+
+use keyboard_types::{Code, Key, Location, Modifiers};
+use smol_str::SmolStr;
+
+/// Keyboard modifiers as a bitmask matching JS `MouseEvent` flags:
+/// shift=1, ctrl=2, alt=4, meta=8 (same packing the TS router produces).
+pub fn mods_from_bits(bits: u8) -> Modifiers {
+    let mut m = Modifiers::empty();
+    if bits & 1 != 0 {
+        m |= Modifiers::SHIFT;
+    }
+    if bits & 2 != 0 {
+        m |= Modifiers::CONTROL;
+    }
+    if bits & 4 != 0 {
+        m |= Modifiers::ALT;
+    }
+    if bits & 8 != 0 {
+        m |= Modifiers::META;
+    }
+    m
+}
+
+#[derive(Debug)]
+pub enum PendingInput {
+    /// kind: 0=move 1=down 2=up 3=cancel
+    Pointer { kind: u8, x: f64, y: f64, button: u8, mods: u8 },
+    Wheel { dx: f64, dy: f64, x: f64, y: f64, mods: u8 },
+    /// pressed: true=keydown false=keyup
+    Key { pressed: bool, key: String, code: String, mods: u8, text: Option<String> },
+    PointerLeave,
+}
+
+impl PendingInput {
+    pub fn key_event(
+        pressed: bool,
+        key: &str,
+        code: &str,
+        mods: u8,
+        text: Option<String>,
+    ) -> blitz_traits::events::BlitzKeyEvent {
+        use blitz_traits::events::{BlitzKeyEvent, KeyState};
+        let key = match key {
+            "Escape" => Key::Escape,
+            "Enter" => Key::Enter,
+            "Tab" => Key::Tab,
+            "Backspace" => Key::Backspace,
+            "Delete" => Key::Delete,
+            "ArrowUp" => Key::ArrowUp,
+            "ArrowDown" => Key::ArrowDown,
+            "ArrowLeft" => Key::ArrowLeft,
+            "ArrowRight" => Key::ArrowRight,
+            "Alt" => Key::Alt,
+            "Shift" => Key::Shift,
+            "Control" => Key::Control,
+            "Meta" => Key::Meta,
+            other => Key::Character(other.to_string()),
+        };
+        BlitzKeyEvent {
+            key,
+            code: Code::from_str(code).unwrap_or(Code::Unidentified),
+            modifiers: mods_from_bits(mods),
+            location: Location::Standard,
+            is_auto_repeating: false,
+            is_composing: false,
+            state: if pressed { KeyState::Pressed } else { KeyState::Released },
+            text: text.map(SmolStr::new),
+        }
+    }
+}

package/libraries/blitz-ui/native/src/lib.rs

@@ -0,0 +1,96 @@
+//! downdraft-blitz-shell — shared headless Blitz/Dioxus UI shell.
+//!
+//! This crate owns everything except the game's UI: the vdom driver,
+//! vello_cpu rasterizer, input dispatch, and the JS bridge. Game crates
+//! provide the Dioxus root component and a snapshot applier through
+//! `ShellConfig`, and re-expose `#[wasm_bindgen]` entry points as thin
+//! shims (see `games/sandjongg/blitz-ui` for the pattern).
+//!
+//! Coordinates passed to `push_input`/`hit_test` are canvas *backing*
+//! (physical) pixels — the engine's InputManager already converts DOM
+//! client coords to canvas space.
+
+mod bridge;
+mod fonts;
+mod input;
+mod shell;
+
+/// Minimal console bindings so the shell can report snapshot errors
+/// without pulling web_sys into the crate.
+pub mod console {
+    use wasm_bindgen::prelude::*;
+
+    #[wasm_bindgen]
+    extern "C" {
+        #[wasm_bindgen(js_namespace = console)]
+        pub fn warn(s: &str);
+        #[wasm_bindgen(js_namespace = console)]
+        pub fn error(s: &str);
+        #[wasm_bindgen(js_namespace = console)]
+        pub fn log(s: &str);
+    }
+}
+
+pub use bridge::{BRIDGE, GameBridge, dispatch_action, hit_test as doc_hit_test, push_input, push_snapshot, set_action_cb};
+pub use input::PendingInput;
+pub use shell::{ShellConfig, frame, init, resize, shutdown, tick};
+
+/// Is (x, y) — physical px — over an interactive UI element? Used by the
+/// engine router so clicks on transparent areas fall through to the game.
+/// Conservatively returns true if the document is mid-mutation.
+pub fn hit_test(x: f64, y: f64) -> bool {
+    BRIDGE.with(|b| {
+        let b = b.borrow();
+        let Some(doc) = &b.doc else { return false };
+        let result = match doc.try_borrow() {
+            Ok(doc) => doc_hit_test(&doc, x, y),
+            // Reentrant call while an event/render holds the borrow — the
+            // pointer is interacting with the UI, so claim it.
+            Err(_) => true,
+        };
+        result
+    })
+}
+
+/// Debug: dump the DOM tree (interactive nodes marked with `*`).
+pub fn dump_dom() -> String {
+    fn walk(
+        doc: &blitz_dom::BaseDocument,
+        id: blitz_dom::NodeId,
+        depth: usize,
+        out: &mut String,
+    ) {
+        let Some(node) = doc.get_node(id) else { return };
+        let marker = if node.attr(blitz_dom::LocalName::from("data-ui")).is_some() {
+            "*"
+        } else {
+            " "
+        };
+        let tag = node
+            .element_data()
+            .map(|e| e.name.local.to_string())
+            .or_else(|| node.text_data().map(|_| "#text".to_string()))
+            .unwrap_or_else(|| "#node".to_string());
+        out.push_str(&format!("{}{} {:?}\n", "  ".repeat(depth), marker, tag));
+        for &child in node.children.iter() {
+            walk(doc, child, depth + 1, out);
+        }
+    }
+
+    BRIDGE.with(|b| {
+        let b = b.borrow();
+        let Some(doc) = &b.doc else {
+            return String::from("(no document)");
+        };
+        let result = match doc.try_borrow() {
+            Ok(doc) => {
+                let mut out = String::new();
+                let root = doc.root_node().id;
+                walk(&doc, root, 0, &mut out);
+                out
+            }
+            Err(_) => String::from("(document borrowed)"),
+        };
+        result
+    })
+}

package/libraries/blitz-ui/native/src/shell.rs

@@ -0,0 +1,301 @@
+//! Generic headless driver: no winit, no web-sys. The host calls `tick`
+//! once per frame; it drains pending state/input, polls the vdom, and
+//! re-rasterizes with vello_cpu when dirty. `frame` returns the RGBA8
+//! buffer which the host uploads to a texture / 2D canvas.
+//!
+//! Game-specific surface is injected via `ShellConfig`: the Dioxus root
+//! component and a snapshot applier that deserializes the raw JSON pushed
+//! by `push_snapshot` and writes the game's own UI state inside
+//! `vdom.in_scope`.
+
+use std::cell::RefCell;
+use std::rc::Rc;
+use std::sync::Arc;
+
+use anyrender::ImageRenderer;
+use anyrender_vello_cpu::VelloCpuImageRenderer;
+use atomic_refcell::AtomicRefCell;
+use blitz_dom::Document;
+use blitz_paint::paint_scene;
+use blitz_traits::events::{
+    BlitzPointerEvent, BlitzPointerId, BlitzWheelDelta, BlitzWheelEvent, MouseEventButton,
+    MouseEventButtons, PointerCoords, PointerDetails, UiEvent,
+};
+use blitz_traits::shell::{ColorScheme, Viewport};
+use dioxus_core::{Element, VirtualDom};
+use dioxus_native::DioxusDocument;
+use web_time::Instant;
+
+use crate::bridge::{BRIDGE, GameBridge};
+use crate::input::{PendingInput, mods_from_bits};
+
+/// Game-provided hooks. `apply_snapshot` runs inside `tick` whenever the
+/// host pushed raw snapshot JSON — the game deserializes into its own
+/// snapshot type and applies it (typically writing a global signal inside
+/// `vdom.in_scope(ScopeId::ROOT, ...)`).
+pub struct ShellConfig {
+    pub root: fn() -> Element,
+    /// Returns Err(msg) to log a warning (bad snapshot payload etc.).
+    pub apply_snapshot: Rc<dyn Fn(&mut VirtualDom, &str) -> Result<(), String>>,
+    /// WOFF/WOFF2 bytes for the single-font fallback context. `None` uses
+    /// the engine's embedded DejaVu Sans.
+    pub font: Option<&'static [u8]>,
+}
+
+pub struct HeadlessShell {
+    doc: DioxusDocument,
+    renderer: VelloCpuImageRenderer,
+    buttons: MouseEventButtons,
+    /// Physical-pixel pointer position (mirrors `View::pointer_pos`).
+    pointer_pos: (f64, f64),
+    active_events: Arc<AtomicRefCell<Vec<BlitzPointerEvent>>>,
+    anim_start: Option<Instant>,
+    dirty: bool,
+    apply_snapshot: Rc<dyn Fn(&mut VirtualDom, &str) -> Result<(), String>>,
+}
+
+thread_local! {
+    static HEADLESS: RefCell<Option<HeadlessShell>> = const { RefCell::new(None) };
+}
+
+fn with_shell<R>(f: impl FnOnce(&mut HeadlessShell) -> R) -> Option<R> {
+    HEADLESS.with(|h| h.borrow_mut().as_mut().map(f))
+}
+
+impl HeadlessShell {
+    fn new(config: ShellConfig, width: u32, height: u32, scale: f32) -> Self {
+        let vdom = VirtualDom::new(config.root);
+        let mut doc = DioxusDocument::new(
+            vdom,
+            blitz_dom::DocumentConfig {
+                font_ctx: Some(crate::fonts::font_ctx(config.font)),
+                viewport: Some(Viewport::new(width, height, scale, ColorScheme::Dark)),
+                ..Default::default()
+            },
+        );
+        doc.vdom.insert_any_root_context(Box::new(GameBridge));
+        doc.initial_build();
+
+        // Share the document handle for ui_hit_test / ui_dump.
+        BRIDGE.with(|b| b.borrow_mut().doc = Some(doc.inner.clone()));
+
+        Self {
+            doc,
+            renderer: VelloCpuImageRenderer::new(width, height),
+            buttons: MouseEventButtons::None,
+            pointer_pos: (0.0, 0.0),
+            active_events: Arc::new(AtomicRefCell::new(Vec::new())),
+            anim_start: None,
+            dirty: true,
+            apply_snapshot: config.apply_snapshot,
+        }
+    }
+
+    /// Logical coords from physical px — `View::pointer_coords` with no
+    /// safe-area insets.
+    fn pointer_coords(&self, x: f64, y: f64) -> PointerCoords {
+        let inner = self.doc.inner();
+        let scale = inner.viewport().scale_f64();
+        let sx = (x / scale) as f32;
+        let sy = (y / scale) as f32;
+        let scroll = inner.viewport_scroll();
+        PointerCoords {
+            screen_x: sx,
+            screen_y: sy,
+            client_x: sx,
+            client_y: sy,
+            page_x: sx + scroll.x as f32,
+            page_y: sy + scroll.y as f32,
+        }
+    }
+
+    fn dispatch(&mut self, input: &PendingInput) {
+        match input {
+            PendingInput::Pointer { kind, x, y, button, mods } => {
+                self.pointer_pos = (*x, *y);
+                let btn = match button {
+                    1 => MouseEventButton::Auxiliary,
+                    2 => MouseEventButton::Secondary,
+                    3 => MouseEventButton::Fourth,
+                    4 => MouseEventButton::Fifth,
+                    _ => MouseEventButton::Main,
+                };
+                match kind {
+                    1 => self.buttons |= MouseEventButtons::from(btn),
+                    2 => self.buttons ^= MouseEventButtons::from(btn),
+                    _ => {}
+                }
+                let event = BlitzPointerEvent {
+                    id: BlitzPointerId::Mouse,
+                    is_primary: true,
+                    coords: self.pointer_coords(*x, *y),
+                    button: btn,
+                    buttons: self.buttons,
+                    mods: mods_from_bits(*mods),
+                    details: PointerDetails::default(),
+                    element: Default::default(),
+                    active_pointers: Arc::clone(&self.active_events),
+                };
+                let ui_event = match kind {
+                    1 => UiEvent::PointerDown(event),
+                    2 => UiEvent::PointerUp(event),
+                    3 => UiEvent::PointerCancel(event),
+                    _ => UiEvent::PointerMove(event),
+                };
+                // A plain hover move only repaints differently when it changes
+                // which element is hovered — the driver fires no DOM events
+                // otherwise. Compare hover before/after and skip the raster
+                // when nothing changed (every mousemove over the board would
+                // otherwise force a full-screen re-raster). Clicks and drags
+                // always dirty: they can trigger actions, and held-button
+                // gestures (sliders) repaint continuously.
+                let prev_hover = if *kind == 0 && self.buttons == MouseEventButtons::None {
+                    self.doc.inner().get_hover_node_id()
+                } else {
+                    None
+                };
+                self.doc.handle_ui_event(ui_event);
+                if *kind == 0 && self.buttons == MouseEventButtons::None {
+                    if self.doc.inner().get_hover_node_id() != prev_hover {
+                        self.dirty = true;
+                    }
+                } else {
+                    self.dirty = true;
+                }
+            }
+            PendingInput::PointerLeave => {
+                let event = BlitzPointerEvent {
+                    id: BlitzPointerId::Mouse,
+                    is_primary: true,
+                    coords: self.pointer_coords(-1.0, -1.0),
+                    button: MouseEventButton::Main,
+                    buttons: self.buttons,
+                    mods: Default::default(),
+                    details: PointerDetails::default(),
+                    element: Default::default(),
+                    active_pointers: Arc::clone(&self.active_events),
+                };
+                self.doc.handle_ui_event(UiEvent::PointerMove(event));
+                self.dirty = true;
+            }
+            PendingInput::Wheel { dx, dy, x, y, mods } => {
+                self.pointer_pos = (*x, *y);
+                let event = BlitzWheelEvent {
+                    delta: BlitzWheelDelta::Pixels(*dx, *dy),
+                    coords: self.pointer_coords(*x, *y),
+                    buttons: self.buttons,
+                    mods: mods_from_bits(*mods),
+                    element: Default::default(),
+                };
+                self.doc.handle_ui_event(UiEvent::Wheel(event));
+                self.dirty = true;
+            }
+            PendingInput::Key { pressed, key, code, mods, text } => {
+                let kev = PendingInput::key_event(*pressed, key, code, *mods, text.clone());
+                self.doc.handle_ui_event(if *pressed {
+                    UiEvent::KeyDown(kev)
+                } else {
+                    UiEvent::KeyUp(kev)
+                });
+                self.dirty = true;
+            }
+        }
+    }
+
+    /// Drain pending snapshot/input, poll the vdom. Returns true when a
+    /// re-render is needed.
+    fn tick(&mut self) -> bool {
+        let snap = BRIDGE.with(|b| b.borrow_mut().pending_snapshot.take());
+        if let Some(json) = snap {
+            let apply = Rc::clone(&self.apply_snapshot);
+            if let Err(e) = apply(&mut self.doc.vdom, &json) {
+                crate::console::warn(&format!("ui_set_state: {e}"));
+            }
+            self.dirty = true;
+        }
+        loop {
+            let input = BRIDGE.with(|b| b.borrow_mut().pending_events.pop_front());
+            let Some(input) = input else { break };
+            self.dispatch(&input);
+        }
+        if self.doc.poll(None) {
+            self.dirty = true;
+        }
+        self.dirty
+    }
+
+    fn render(&mut self, buffer: &mut Vec<u8>) {
+        let t = match self.anim_start {
+            Some(start) => Instant::now().duration_since(start).as_secs_f64(),
+            None => {
+                self.anim_start = Some(Instant::now());
+                0.0
+            }
+        };
+        let mut inner = self.doc.inner_mut();
+        inner.resolve(t);
+        let (w, h) = inner.viewport().window_size;
+        let scale = inner.viewport().scale_f64();
+        let is_animating = inner.is_animating();
+        let is_blocked = inner.has_pending_critical_resources();
+        if !is_blocked {
+            // The scene painter retains draw commands across renders —
+            // reset first or every frame composites over the last one.
+            self.renderer.reset();
+            self.renderer.render_to_vec(
+                |scene| paint_scene(scene, &mut inner, scale, w, h, 0, 0),
+                buffer,
+            );
+        }
+        self.dirty = is_animating;
+    }
+}
+
+// ---- public API (game crates expose these via #[wasm_bindgen] shims) ----
+
+pub fn init(config: ShellConfig, width: f64, height: f64, scale: f64) {
+    console_error_panic_hook::set_once();
+    BRIDGE.with(|b| b.borrow_mut().shutdown = false);
+    let shell = HeadlessShell::new(
+        config,
+        width.max(1.0) as u32,
+        height.max(1.0) as u32,
+        if scale > 0.0 { scale as f32 } else { 1.0 },
+    );
+    HEADLESS.with(|h| *h.borrow_mut() = Some(shell));
+}
+
+pub fn resize(width: f64, height: f64, scale: f64) {
+    with_shell(|ui| {
+        let w = width.max(1.0) as u32;
+        let h = height.max(1.0) as u32;
+        {
+            let mut inner = ui.doc.inner_mut();
+            let mut vp = inner.viewport_mut();
+            vp.window_size = (w, h);
+            if scale > 0.0 {
+                vp.set_hidpi_scale(scale as f32);
+            }
+        }
+        ui.renderer.resize(w, h);
+        ui.dirty = true;
+    });
+}
+
+/// Drain queued work + poll vdom. Returns true if `frame` should be
+/// called to get fresh pixels.
+pub fn tick() -> bool {
+    with_shell(|ui| ui.tick()).unwrap_or(false)
+}
+
+/// Rasterize into an RGBA8 buffer. Only call when `tick` returned true.
+pub fn frame() -> Vec<u8> {
+    let mut buffer = Vec::new();
+    with_shell(|ui| ui.render(&mut buffer));
+    buffer
+}
+
+pub fn shutdown() {
+    HEADLESS.with(|h| *h.borrow_mut() = None);
+    BRIDGE.with(|b| b.borrow_mut().shutdown = true);
+}

package/libraries/blitz-ui/native-osr/Cargo.toml

@@ -0,0 +1,24 @@
+[package]
+name = "downdraft-blitz-osr"
+version = "0.1.0"
+edition = "2021"
+publish = false
+description = "Headless Blitz HtmlDocument rasterizer exposed over a C ABI (native OSR spike)"
+
+[lib]
+name = "downdraft_blitz_osr"
+crate-type = ["cdylib"]
+
+[dependencies]
+blitz-html = { git = "https://github.com/DioxusLabs/blitz", rev = "efef6519fe6520caf66dc82df557580eecbf652b" }
+blitz-dom = { git = "https://github.com/DioxusLabs/blitz", rev = "efef6519fe6520caf66dc82df557580eecbf652b", default-features = false, features = ["woff"] }
+blitz-traits = { git = "https://github.com/DioxusLabs/blitz", rev = "efef6519fe6520caf66dc82df557580eecbf652b" }
+blitz-paint = { git = "https://github.com/DioxusLabs/blitz", rev = "efef6519fe6520caf66dc82df557580eecbf652b", features = ["custom-widget"] }
+anyrender_vello_cpu = "0.17.0"
+anyrender = "0.13.0"
+atomic_refcell = "0.1"
+keyboard-types = "0.7"
+linebender_resource_handle = "0.1"
+# Workaround copied from blitz examples: disable unicode URL support
+# (see https://github.com/hsivonen/idna_adapter)
+idna_adapter = "=1.0.0"