@effindomv2/fui-rs 0.1.3

package/src/bitmap.rs

@@ -0,0 +1,317 @@
+use crate::assets;
+use crate::drawing::DrawContext;
+use crate::ffi;
+use crate::frame_scheduler::on_loaded;
+use crate::logger::error;
+use crate::node::Node;
+use crate::text::TextLayout;
+use std::cell::RefCell;
+use std::rc::Rc;
+
+const MAX_DIRTY_RECTS: usize = 16;
+
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
+pub struct BitmapTextReadyEventArgs;
+
+impl BitmapTextReadyEventArgs {
+    pub const EMPTY: Self = Self;
+}
+
+struct BitmapState {
+    width: u32,
+    height: u32,
+    texture_id: u32,
+    pixel_bytes: Vec<u8>,
+    offscreen_id: u32,
+    canvas_used: bool,
+    draw_context: Option<DrawContext>,
+    disposed: bool,
+    dirty_rects: Vec<(u32, u32, u32, u32)>,
+}
+
+#[derive(Clone)]
+pub struct Bitmap {
+    inner: Rc<RefCell<BitmapState>>,
+}
+
+impl Bitmap {
+    pub fn new(width: u32, height: u32) -> Self {
+        assert!(
+            width > 0 && height > 0,
+            "Bitmap width and height must be greater than zero."
+        );
+        let byte_len = (width as usize)
+            .checked_mul(height as usize)
+            .and_then(|value| value.checked_mul(4))
+            .expect("Bitmap byte length overflow.");
+        let texture_id = assets::allocate_dynamic_texture_id();
+        let offscreen_id = unsafe { ffi::fui_canvas_create_offscreen(width, height) };
+        Self {
+            inner: Rc::new(RefCell::new(BitmapState {
+                width,
+                height,
+                texture_id,
+                pixel_bytes: vec![0; byte_len],
+                offscreen_id,
+                canvas_used: false,
+                draw_context: None,
+                disposed: false,
+                dirty_rects: Vec::new(),
+            })),
+        }
+    }
+
+    pub fn width(&self) -> u32 {
+        self.inner.borrow().width
+    }
+
+    pub fn height(&self) -> u32 {
+        self.inner.borrow().height
+    }
+
+    pub fn texture_id(&self) -> u32 {
+        self.inner.borrow().texture_id
+    }
+
+    pub fn pixels(&self) -> std::cell::RefMut<'_, Vec<u8>> {
+        std::cell::RefMut::map(self.inner.borrow_mut(), |state| {
+            assert!(!state.disposed, "Bitmap.pixels() called after dispose.");
+            &mut state.pixel_bytes
+        })
+    }
+
+    pub fn pixel_ptr(&self) -> usize {
+        let state = self.inner.borrow();
+        if state.pixel_bytes.is_empty() {
+            0
+        } else {
+            state.pixel_bytes.as_ptr() as usize
+        }
+    }
+
+    pub fn canvas(&self) -> DrawContext {
+        let mut state = self.inner.borrow_mut();
+        assert!(!state.disposed, "Bitmap.canvas() called after dispose.");
+        state.canvas_used = true;
+        if let Some(context) = &state.draw_context {
+            return context.clone();
+        }
+        let ptr = unsafe { ffi::fui_canvas_get_offscreen_ptr(state.offscreen_id) };
+        let context = DrawContext::new(ptr);
+        state.draw_context = Some(context.clone());
+        context
+    }
+
+    pub fn render<T: Node>(&self, node: &T, x: f32, y: f32, scale: f32) {
+        let state = self.inner.borrow();
+        assert!(!state.disposed, "Bitmap.render() called after dispose.");
+        let handle = node.handle().raw();
+        if handle == 0 {
+            return;
+        }
+        unsafe {
+            ffi::fui_render_node_to_rgba(
+                handle,
+                state.width,
+                state.height,
+                state.pixel_bytes.as_ptr() as usize,
+                state.pixel_bytes.len() as u32,
+                scale,
+                x,
+                y,
+            )
+        };
+    }
+
+    pub fn render_text_layout(&self, layout: &TextLayout, x: f32, y: f32, scale: f32) {
+        if !layout.is_ready() {
+            error(
+                "TextLayout",
+                "Bitmap.render_text_layout() called before the TextLayout was ready; register on_ready and render after the callback.",
+            );
+            return;
+        }
+        let node = layout.draw_node();
+        self.render(&node, x, y, scale);
+    }
+
+    pub fn prepare_text<T: Node>(node: &T) {
+        crate::bindings::ui::prepare_node(node.handle().raw());
+    }
+
+    pub fn on_text_ready<T: Node + Clone + 'static>(
+        &self,
+        node: &T,
+        callback: impl FnOnce(BitmapTextReadyEventArgs) + 'static,
+    ) -> &Self {
+        let node = node.clone();
+        on_loaded(move |_| {
+            Self::prepare_text(&node);
+            callback(BitmapTextReadyEventArgs::EMPTY);
+        });
+        self
+    }
+
+    pub fn dirty_rect(&self, x: u32, y: u32, w: u32, h: u32) -> &Self {
+        let mut state = self.inner.borrow_mut();
+        if w == 0 || h == 0 || x >= state.width || y >= state.height {
+            return self;
+        }
+        let cw = (x + w).min(state.width) - x;
+        let ch = (y + h).min(state.height) - y;
+        if state.dirty_rects.len() < MAX_DIRTY_RECTS {
+            state.dirty_rects.push((x, y, cw, ch));
+        }
+        self
+    }
+
+    pub fn clear_dirty_rects(&self) -> &Self {
+        self.inner.borrow_mut().dirty_rects.clear();
+        self
+    }
+
+    pub fn has_dirty_rects(&self) -> bool {
+        !self.inner.borrow().dirty_rects.is_empty()
+    }
+
+    pub fn commit(&self) -> u32 {
+        let mut state = self.inner.borrow_mut();
+        assert!(!state.disposed, "Bitmap.commit() called after dispose.");
+        if state.canvas_used {
+            if let Some(context) = &state.draw_context {
+                context.flush();
+            }
+            unsafe {
+                ffi::fui_canvas_read_offscreen_pixels(
+                    state.offscreen_id,
+                    state.pixel_bytes.as_mut_ptr() as usize,
+                    state.width,
+                    state.height,
+                )
+            };
+        }
+        if state.dirty_rects.is_empty() {
+            unsafe {
+                ffi::fui_bitmap_commit(
+                    state.texture_id,
+                    state.pixel_bytes.as_ptr() as usize,
+                    state.pixel_bytes.len() as u32,
+                    state.width,
+                    state.height,
+                )
+            };
+        } else {
+            let dirty_rects = std::mem::take(&mut state.dirty_rects);
+            for (x, y, w, h) in dirty_rects {
+                let mut rect_bytes = vec![0u8; (w as usize) * (h as usize) * 4];
+                for row in 0..h as usize {
+                    let src = (((y as usize + row) * state.width as usize) + x as usize) * 4;
+                    let dst = row * w as usize * 4;
+                    let len = w as usize * 4;
+                    rect_bytes[dst..dst + len].copy_from_slice(&state.pixel_bytes[src..src + len]);
+                }
+                unsafe {
+                    ffi::fui_bitmap_commit_dirty(
+                        state.texture_id,
+                        rect_bytes.as_ptr() as usize,
+                        rect_bytes.len() as u32,
+                        state.width,
+                        state.height,
+                        x,
+                        y,
+                        w,
+                        h,
+                    )
+                };
+            }
+        }
+        assets::mark_texture_asset_ready(state.texture_id, state.width as f32, state.height as f32);
+        state.texture_id
+    }
+
+    pub fn dispose(&self) {
+        let mut state = self.inner.borrow_mut();
+        if state.disposed {
+            return;
+        }
+        state.disposed = true;
+        unsafe { ffi::fui_canvas_destroy_offscreen(state.offscreen_id) };
+        unsafe { ffi::fui_bitmap_release(state.texture_id) };
+        state.pixel_bytes.clear();
+        state.draw_context = None;
+    }
+}
+
+impl Drop for Bitmap {
+    fn drop(&mut self) {
+        if Rc::strong_count(&self.inner) == 1 {
+            self.dispose();
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::Bitmap;
+    use crate::drawing::Paint;
+    use crate::ffi::{self, Call};
+
+    #[test]
+    fn bitmap_canvas_commit_flushes_offscreen_and_marks_asset_ready() {
+        ffi::test::reset();
+        let bitmap = Bitmap::new(32, 24);
+        let canvas = bitmap.canvas();
+        canvas.draw_rect(0.0, 0.0, 10.0, 12.0, Paint::fill(0xFF00FFFF));
+        bitmap.commit();
+
+        let calls = ffi::test::take_calls();
+        assert!(calls.iter().any(|call| matches!(
+            call,
+            Call::CanvasCreateOffscreen {
+                width: 32,
+                height: 24,
+                ..
+            }
+        )));
+        assert!(calls
+            .iter()
+            .any(|call| matches!(call, Call::CanvasDrawBatch { .. })));
+        assert!(calls.iter().any(|call| matches!(
+            call,
+            Call::CanvasReadOffscreenPixels {
+                width: 32,
+                height: 24,
+                ..
+            }
+        )));
+        assert!(calls.iter().any(|call| matches!(
+            call,
+            Call::BitmapCommit {
+                width: 32,
+                height: 24,
+                ..
+            }
+        )));
+    }
+
+    #[test]
+    fn bitmap_dirty_commit_uses_subrect_upload() {
+        ffi::test::reset();
+        let bitmap = Bitmap::new(8, 6);
+        bitmap.dirty_rect(2, 1, 3, 2).commit();
+
+        let calls = ffi::test::take_calls();
+        assert!(calls.iter().any(|call| matches!(
+            call,
+            Call::BitmapCommitDirty {
+                full_width: 8,
+                full_height: 6,
+                sub_x: 2,
+                sub_y: 1,
+                sub_w: 3,
+                sub_h: 2,
+                ..
+            }
+        )));
+    }
+}

package/src/bridge_callbacks.rs

@@ -0,0 +1,242 @@
+use crate::animation;
+use crate::assets;
+use crate::bindings::ui;
+use crate::context_menu_manager;
+use crate::event;
+use crate::frame_signal;
+use crate::viewport;
+use crate::Application;
+use std::cell::{Cell, RefCell};
+
+#[derive(Clone, Debug, Default, PartialEq)]
+pub struct ScrollEvent {
+    pub handle: u64,
+    pub offset_x: f32,
+    pub offset_y: f32,
+    pub content_width: f32,
+    pub content_height: f32,
+    pub viewport_width: f32,
+    pub viewport_height: f32,
+}
+
+#[derive(Clone, Debug, Default, PartialEq)]
+pub struct ContextMenuRequest {
+    pub handle: u64,
+    pub x: f32,
+    pub y: f32,
+}
+
+#[derive(Clone, Debug, Default, PartialEq, Eq)]
+pub struct AssetFailure {
+    pub id: u32,
+    pub error: String,
+}
+
+#[derive(Clone, Debug, Default, PartialEq)]
+pub struct AssetReady {
+    pub id: u32,
+    pub width: f32,
+    pub height: f32,
+}
+
+thread_local! {
+    static CURRENT_ROUTE: RefCell<String> = const { RefCell::new(String::new()) };
+    static LAST_SCROLL: RefCell<Option<ScrollEvent>> = const { RefCell::new(None) };
+    static LAST_CONTEXT_MENU: RefCell<Option<ContextMenuRequest>> = const { RefCell::new(None) };
+    static CONTEXT_MENU_VISIBLE: Cell<bool> = const { Cell::new(false) };
+    static LAST_FONT_LOADED: Cell<Option<u32>> = const { Cell::new(None) };
+    static LAST_SVG_LOADED: RefCell<Option<AssetReady>> = const { RefCell::new(None) };
+    static LAST_SVG_FAILED: RefCell<Option<AssetFailure>> = const { RefCell::new(None) };
+    static LAST_TEXTURE_LOADED: RefCell<Option<AssetReady>> = const { RefCell::new(None) };
+    static LAST_TEXTURE_FAILED: RefCell<Option<AssetFailure>> = const { RefCell::new(None) };
+    static PERSIST_CAPTURE_COUNT: Cell<u32> = const { Cell::new(0) };
+    static PERSIST_RESTORE_COUNT: Cell<u32> = const { Cell::new(0) };
+}
+
+fn read_utf8(ptr: *const u8, len: u32) -> String {
+    if ptr.is_null() || len == 0 {
+        return String::new();
+    }
+    let bytes = unsafe { std::slice::from_raw_parts(ptr, len as usize) };
+    String::from_utf8_lossy(bytes).into_owned()
+}
+
+pub fn current_route() -> String {
+    CURRENT_ROUTE.with(|route| route.borrow().clone())
+}
+
+pub fn last_scroll_event() -> Option<ScrollEvent> {
+    LAST_SCROLL.with(|event| event.borrow().clone())
+}
+
+pub fn last_context_menu_request() -> Option<ContextMenuRequest> {
+    LAST_CONTEXT_MENU.with(|event| event.borrow().clone())
+}
+
+pub fn is_context_menu_visible() -> bool {
+    CONTEXT_MENU_VISIBLE.with(Cell::get)
+}
+
+pub fn last_font_loaded() -> Option<u32> {
+    LAST_FONT_LOADED.with(Cell::get)
+}
+
+pub fn last_svg_loaded() -> Option<AssetReady> {
+    LAST_SVG_LOADED.with(|event| event.borrow().clone())
+}
+
+pub fn last_svg_failed() -> Option<AssetFailure> {
+    LAST_SVG_FAILED.with(|event| event.borrow().clone())
+}
+
+pub fn last_texture_loaded() -> Option<AssetReady> {
+    LAST_TEXTURE_LOADED.with(|event| event.borrow().clone())
+}
+
+pub fn last_texture_failed() -> Option<AssetFailure> {
+    LAST_TEXTURE_FAILED.with(|event| event.borrow().clone())
+}
+
+pub fn persisted_capture_count() -> u32 {
+    PERSIST_CAPTURE_COUNT.with(Cell::get)
+}
+
+pub fn persisted_restore_count() -> u32 {
+    PERSIST_RESTORE_COUNT.with(Cell::get)
+}
+
+#[no_mangle]
+pub extern "C" fn __fui_on_viewport_changed(width: f32, height: f32) {
+    ui::resize_window(width, height);
+    viewport::set_viewport_size(width, height);
+}
+
+#[no_mangle]
+pub extern "C" fn __fui_on_frame(timestamp_ms: f64) {
+    frame_signal::set_frame_time(timestamp_ms);
+    animation::tick_animations(timestamp_ms);
+}
+
+#[no_mangle]
+pub extern "C" fn __fui_on_route_changed(route_ptr: *const u8, route_len: u32) {
+    let route = read_utf8(route_ptr, route_len);
+    CURRENT_ROUTE.with(|slot| slot.replace(route));
+}
+
+#[no_mangle]
+pub extern "C" fn __fui_on_scroll(
+    handle: u64,
+    offset_x: f32,
+    offset_y: f32,
+    content_width: f32,
+    content_height: f32,
+    viewport_width: f32,
+    viewport_height: f32,
+) {
+    LAST_SCROLL.with(|slot| {
+        slot.replace(Some(ScrollEvent {
+            handle,
+            offset_x,
+            offset_y,
+            content_width,
+            content_height,
+            viewport_width,
+            viewport_height,
+        }));
+    });
+    event::dispatch_scroll(
+        crate::node::NodeHandle::from_raw(handle),
+        offset_x,
+        offset_y,
+        content_width,
+        content_height,
+        viewport_width,
+        viewport_height,
+    );
+}
+
+#[no_mangle]
+pub extern "C" fn __fui_can_show_context_menu(handle: u64) -> bool {
+    context_menu_manager::can_show_for_handle(handle)
+}
+
+#[no_mangle]
+pub extern "C" fn __fui_on_context_menu(handle: u64, x: f32, y: f32) {
+    LAST_CONTEXT_MENU.with(|slot| slot.replace(Some(ContextMenuRequest { handle, x, y })));
+    let shown = context_menu_manager::show_for_current_selection(handle, x, y);
+    CONTEXT_MENU_VISIBLE.with(|visible| visible.set(shown));
+}
+
+#[no_mangle]
+pub extern "C" fn __fui_hide_active_context_menu() {
+    context_menu_manager::hide_active_menu();
+    CONTEXT_MENU_VISIBLE.with(|visible| visible.set(false));
+}
+
+#[no_mangle]
+pub extern "C" fn __fui_on_font_loaded(font_id: u32) {
+    LAST_FONT_LOADED.with(|slot| slot.set(Some(font_id)));
+    assets::on_font_loaded(font_id);
+    crate::typography::notify_font_loaded(font_id);
+    crate::text::notify_font_loaded(font_id);
+}
+
+#[no_mangle]
+pub extern "C" fn __fui_on_svg_loaded(svg_id: u32, width: f32, height: f32) {
+    LAST_SVG_LOADED.with(|slot| {
+        slot.replace(Some(AssetReady {
+            id: svg_id,
+            width,
+            height,
+        }))
+    });
+    assets::on_svg_loaded(svg_id, width, height);
+}
+
+#[no_mangle]
+pub extern "C" fn __fui_on_svg_failed(svg_id: u32, error_ptr: *const u8, error_len: u32) {
+    let error = read_utf8(error_ptr, error_len);
+    LAST_SVG_FAILED.with(|slot| {
+        slot.replace(Some(AssetFailure {
+            id: svg_id,
+            error: error.clone(),
+        }))
+    });
+    assets::on_svg_failed(svg_id, error);
+}
+
+#[no_mangle]
+pub extern "C" fn __fui_on_texture_loaded(texture_id: u32, width: f32, height: f32) {
+    LAST_TEXTURE_LOADED.with(|slot| {
+        slot.replace(Some(AssetReady {
+            id: texture_id,
+            width,
+            height,
+        }))
+    });
+    assets::on_texture_loaded(texture_id, width, height);
+}
+
+#[no_mangle]
+pub extern "C" fn __fui_on_texture_failed(texture_id: u32, error_ptr: *const u8, error_len: u32) {
+    let error = read_utf8(error_ptr, error_len);
+    LAST_TEXTURE_FAILED.with(|slot| {
+        slot.replace(Some(AssetFailure {
+            id: texture_id,
+            error: error.clone(),
+        }))
+    });
+    assets::on_texture_failed(texture_id, error);
+}
+
+#[no_mangle]
+pub extern "C" fn __fui_capture_persisted_ui_state() {
+    PERSIST_CAPTURE_COUNT.with(|count| count.set(count.get() + 1));
+    Application::capture_persisted_ui_state();
+}
+
+#[no_mangle]
+pub extern "C" fn __fui_restore_persisted_ui_state() {
+    PERSIST_RESTORE_COUNT.with(|count| count.set(count.get() + 1));
+    Application::restore_persisted_ui_state();
+}