@bornengine/engine 0.4.16 → 0.5.1

package/native/shared/src/ui/input.rs

@@ -0,0 +1,173 @@
+use std::collections::VecDeque;
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub struct UiPointerButtonEvent {
+    pub button: u8,
+    pub pressed: bool,
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub struct UiKeyEvent {
+    pub key: u32,
+    pub pressed: bool,
+    pub repeated: bool,
+}
+
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub enum UiInputEvent {
+    Key(UiKeyEvent),
+    Text(String),
+}
+
+#[derive(Clone, Copy, Debug, Default, Eq, PartialEq)]
+pub struct UiModifiers {
+    pub shift: bool,
+    pub ctrl: bool,
+    pub alt: bool,
+    pub super_key: bool,
+}
+
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub struct UiTouchEvent {
+    pub slot: usize,
+    pub x: f64,
+    pub y: f64,
+    pub active: bool,
+    pub released: bool,
+}
+
+#[derive(Clone, Debug, Default, PartialEq)]
+pub struct UiInputSnapshot {
+    pub pointer_position: Option<[f64; 2]>,
+    pub pointer_delta: [f64; 2],
+    pub pointer_buttons: Vec<UiPointerButtonEvent>,
+    pub scroll_x: f64,
+    pub scroll_y: f64,
+    /// Text and keyboard events in their original platform delivery order.
+    pub ordered_events: Vec<UiInputEvent>,
+    pub keys: Vec<UiKeyEvent>,
+    pub modifiers: UiModifiers,
+    pub text: Vec<String>,
+    pub touches: Vec<UiTouchEvent>,
+}
+
+impl UiInputSnapshot {
+    pub fn ordered_key_text_events(&self) -> Vec<UiInputEvent> {
+        if !self.ordered_events.is_empty() {
+            return self.ordered_events.clone();
+        }
+
+        self.keys
+            .iter()
+            .copied()
+            .map(UiInputEvent::Key)
+            .chain(self.text.iter().cloned().map(UiInputEvent::Text))
+            .collect()
+    }
+}
+
+#[derive(Default)]
+pub struct UiInputBridge {
+    pending_text: Vec<String>,
+    text_focused: bool,
+    keyboard_requests: VecDeque<bool>,
+}
+
+impl UiInputBridge {
+    pub fn inject_text(&mut self, text: String) {
+        if !text.is_empty() {
+            self.pending_text.push(text);
+        }
+    }
+
+    pub fn merge_snapshot(&mut self, mut snapshot: UiInputSnapshot) -> UiInputSnapshot {
+        if snapshot.ordered_events.is_empty() {
+            snapshot.ordered_events.extend(
+                snapshot
+                    .keys
+                    .iter()
+                    .copied()
+                    .map(UiInputEvent::Key)
+                    .chain(snapshot.text.iter().cloned().map(UiInputEvent::Text)),
+            );
+        }
+        for text in self.pending_text.drain(..) {
+            snapshot
+                .ordered_events
+                .push(UiInputEvent::Text(text.clone()));
+            snapshot.text.push(text);
+        }
+        snapshot
+    }
+
+    pub fn set_text_focus(&mut self, focused: bool) {
+        if focused != self.text_focused {
+            self.text_focused = focused;
+            self.keyboard_requests.push_back(focused);
+        }
+    }
+
+    pub fn take_keyboard_request(&mut self) -> Option<bool> {
+        self.keyboard_requests.pop_front()
+    }
+
+    #[cfg(test)]
+    pub fn take_keyboard_requests(&mut self) -> Vec<bool> {
+        self.keyboard_requests.drain(..).collect()
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::{UiInputBridge, UiInputEvent, UiInputSnapshot, UiKeyEvent};
+
+    #[test]
+    fn ui_text_injection_preserves_a_complete_unicode_event() {
+        let mut bridge = UiInputBridge::default();
+        bridge.inject_text("東京".to_owned());
+        let snapshot = bridge.merge_snapshot(UiInputSnapshot::default());
+
+        assert_eq!(snapshot.text, ["東京"]);
+        assert_eq!(
+            snapshot.ordered_events,
+            [UiInputEvent::Text("東京".to_owned())]
+        );
+    }
+
+    #[test]
+    fn bridge_appends_injected_text_after_existing_key_events() {
+        let mut bridge = UiInputBridge::default();
+        bridge.inject_text("x".to_owned());
+
+        let snapshot = bridge.merge_snapshot(UiInputSnapshot {
+            keys: vec![UiKeyEvent {
+                key: 8,
+                pressed: true,
+                repeated: false,
+            }],
+            ..Default::default()
+        });
+
+        assert_eq!(
+            snapshot.ordered_events,
+            [
+                UiInputEvent::Key(UiKeyEvent {
+                    key: 8,
+                    pressed: true,
+                    repeated: false,
+                }),
+                UiInputEvent::Text("x".to_owned()),
+            ]
+        );
+    }
+
+    #[test]
+    fn keyboard_focus_requests_only_on_transitions() {
+        let mut bridge = UiInputBridge::default();
+        bridge.set_text_focus(true);
+        bridge.set_text_focus(true);
+        bridge.set_text_focus(false);
+
+        assert_eq!(bridge.take_keyboard_requests(), [true, false]);
+    }
+}

package/native/shared/src/ui/mod.rs

@@ -0,0 +1,252 @@
+mod commands;
+mod egui;
+#[cfg(feature = "debug-ui")]
+mod imgui;
+mod input;
+mod responses;
+
+pub use commands::{UiCommand, UiOpcode};
+pub use egui::{EguiFrameOutput, EguiUi};
+#[cfg(feature = "debug-ui")]
+pub(crate) use imgui::with_dear_imgui;
+#[cfg(feature = "debug-ui")]
+pub use imgui::DearImGuiUi;
+pub use input::{
+    UiInputBridge, UiInputEvent, UiInputSnapshot, UiKeyEvent, UiModifiers, UiPointerButtonEvent,
+    UiTouchEvent,
+};
+pub use responses::UiResponse;
+
+use std::collections::HashMap;
+
+#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)]
+#[repr(u32)]
+pub enum UiBackend {
+    Egui = 0,
+    DearImGui = 1,
+}
+
+impl UiBackend {
+    pub fn from_abi(value: f64) -> Option<Self> {
+        if !value.is_finite() || value < 0.0 || value.fract() != 0.0 || value > u32::MAX as f64 {
+            return None;
+        }
+        match value as u32 {
+            0 => Some(Self::Egui),
+            1 => Some(Self::DearImGui),
+            _ => None,
+        }
+    }
+}
+
+pub fn id_from_abi(value: f64) -> Option<u32> {
+    if !value.is_finite() || value < 0.0 || value.fract() != 0.0 || value > u32::MAX as f64 {
+        return None;
+    }
+    Some(value as u32)
+}
+
+#[derive(Clone, Copy, Debug, Default, PartialEq)]
+pub struct UiCaptureState {
+    pub pointer: bool,
+    pub keyboard: bool,
+}
+
+const MAX_QUEUED_COMMANDS: usize = 16_384;
+const MAX_SCRATCH_VALUES: usize = 1_048_576;
+
+fn color_channel(value: f64) -> u8 {
+    if value.is_finite() {
+        value.clamp(0.0, 255.0).round() as u8
+    } else {
+        255
+    }
+}
+
+#[derive(Default)]
+pub struct UiSystem {
+    commands: Vec<UiCommand>,
+    completed_responses: HashMap<UiBackend, HashMap<u32, UiResponse>>,
+    capture: HashMap<UiBackend, UiCaptureState>,
+    scratch: HashMap<UiBackend, Vec<f64>>,
+    input_bridge: UiInputBridge,
+    input_snapshot: UiInputSnapshot,
+    egui: EguiUi,
+}
+
+impl UiSystem {
+    /// Start a new TypeScript command frame without clearing readback values
+    /// from the most recently completed UI frame.
+    pub fn begin_frame(&mut self) {
+        self.commands.clear();
+        self.scratch.clear();
+    }
+
+    pub fn queue_command(&mut self, command: UiCommand) -> bool {
+        if self.commands.len() >= MAX_QUEUED_COMMANDS {
+            return false;
+        }
+        self.commands.push(command);
+        true
+    }
+
+    pub fn take_commands(&mut self, backend: UiBackend) -> Vec<UiCommand> {
+        let mut selected = Vec::new();
+        self.commands.retain(|command| {
+            if command.backend == backend {
+                selected.push(command.clone());
+                false
+            } else {
+                true
+            }
+        });
+        selected
+    }
+
+    pub fn response(&self, backend: UiBackend, id: u32) -> UiResponse {
+        self.completed_responses
+            .get(&backend)
+            .and_then(|responses| responses.get(&id))
+            .cloned()
+            .unwrap_or_default()
+    }
+
+    pub fn has_response(&self, backend: UiBackend, id: u32) -> bool {
+        self.completed_responses
+            .get(&backend)
+            .is_some_and(|responses| responses.contains_key(&id))
+    }
+
+    pub fn response_text(&self, backend: UiBackend, id: u32) -> String {
+        self.response(backend, id).text
+    }
+
+    pub fn set_input_snapshot(&mut self, snapshot: UiInputSnapshot) {
+        self.input_snapshot = self.input_bridge.merge_snapshot(snapshot);
+    }
+
+    pub fn input_snapshot(&self) -> &UiInputSnapshot {
+        &self.input_snapshot
+    }
+
+    pub fn evaluate_egui(
+        &mut self,
+        screen_rect: [f32; 4],
+        pixels_per_point: f32,
+        dt: f64,
+    ) -> EguiFrameOutput {
+        self.egui.set_native_pixels_per_point(pixels_per_point);
+        let commands = self.take_commands(UiBackend::Egui);
+        let output = self
+            .egui
+            .run_frame(&commands, self.input_snapshot.clone(), screen_rect, dt);
+        self.publish_completed_responses(
+            UiBackend::Egui,
+            output
+                .responses
+                .iter()
+                .map(|(&id, response)| (id, response.clone()))
+                .collect(),
+        );
+        self.set_capture(
+            UiBackend::Egui,
+            UiCaptureState {
+                pointer: output.wants_pointer_input,
+                keyboard: output.wants_keyboard_input,
+            },
+        );
+        self.set_text_focus(output.text_edit_focused);
+        output
+    }
+
+    pub fn publish_completed_responses(
+        &mut self,
+        backend: UiBackend,
+        responses: Vec<(u32, UiResponse)>,
+    ) {
+        self.completed_responses
+            .insert(backend, responses.into_iter().collect());
+    }
+
+    pub fn set_capture(&mut self, backend: UiBackend, capture: UiCaptureState) {
+        self.capture.insert(backend, capture);
+    }
+
+    pub fn wants_input(&self, backend: UiBackend, kind: u32) -> bool {
+        let capture = self.capture.get(&backend).copied().unwrap_or_default();
+        match kind {
+            0 => capture.pointer,
+            1 => capture.keyboard,
+            _ => false,
+        }
+    }
+
+    pub fn is_available(&self, backend: UiBackend) -> bool {
+        match backend {
+            UiBackend::Egui => true,
+            UiBackend::DearImGui => cfg!(feature = "debug-ui"),
+        }
+    }
+
+    pub(crate) fn registered_texture_handles(&self, backend: UiBackend) -> Vec<u64> {
+        self.commands
+            .iter()
+            .filter(|command| {
+                command.backend == backend && command.opcode == UiOpcode::RegisterTexture
+            })
+            .filter_map(|command| {
+                let handle = command.args[0];
+                (handle.is_finite()
+                    && handle >= 0.0
+                    && handle.fract() == 0.0
+                    && handle <= u64::MAX as f64)
+                    .then_some(handle as u64)
+            })
+            .collect()
+    }
+
+    pub fn inject_text(&mut self, text: String) {
+        self.input_bridge.inject_text(text);
+    }
+
+    pub fn set_text_focus(&mut self, focused: bool) {
+        self.input_bridge.set_text_focus(focused);
+    }
+
+    pub fn take_keyboard_request(&mut self) -> Option<bool> {
+        self.input_bridge.take_keyboard_request()
+    }
+
+    pub fn reset_scratch(&mut self, backend: UiBackend) {
+        self.scratch.insert(backend, Vec::new());
+    }
+
+    pub fn push_scratch(&mut self, backend: UiBackend, value: f64) -> bool {
+        let values = self.scratch.entry(backend).or_default();
+        if values.len() >= MAX_SCRATCH_VALUES || !value.is_finite() {
+            return false;
+        }
+        values.push(value);
+        true
+    }
+
+    pub fn queue_scratch_command(
+        &mut self,
+        backend: UiBackend,
+        opcode: UiOpcode,
+        id: u32,
+        count: usize,
+        text: impl Into<String>,
+    ) -> bool {
+        let Some(values) = self.scratch.get_mut(&backend) else {
+            return false;
+        };
+        if count > values.len() || self.commands.len() >= MAX_QUEUED_COMMANDS {
+            return false;
+        }
+        let scratch = values.drain(..count).collect();
+        self.commands
+            .push(UiCommand::new(backend, opcode, id, [0.0; 4], text).with_scratch(scratch));
+        true
+    }
+}

package/native/shared/src/ui/responses.rs

@@ -0,0 +1,61 @@
+#[derive(Clone, Debug, Default, PartialEq)]
+pub struct UiResponse {
+    pub clicked: bool,
+    pub changed: bool,
+    pub hovered: bool,
+    pub focused: bool,
+    pub dragged: bool,
+    pub value: f64,
+    pub text: String,
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::ui::{UiBackend, UiResponse, UiSystem};
+
+    #[test]
+    fn completed_responses_survive_the_next_game_callback_then_replace() {
+        let mut ui = UiSystem::default();
+        ui.begin_frame();
+        ui.publish_completed_responses(
+            UiBackend::Egui,
+            vec![(
+                42,
+                UiResponse {
+                    clicked: true,
+                    ..Default::default()
+                },
+            )],
+        );
+
+        assert!(ui.response(UiBackend::Egui, 42).clicked);
+        assert!(!ui.response(UiBackend::DearImGui, 42).clicked);
+
+        // begin_frame runs before the TypeScript callback; preserve the last
+        // completed response so that callback can read it.
+        ui.begin_frame();
+        assert!(ui.response(UiBackend::Egui, 42).clicked);
+
+        // The response set is replaced only after the next UI evaluation.
+        ui.publish_completed_responses(UiBackend::Egui, vec![]);
+        assert!(!ui.response(UiBackend::Egui, 42).clicked);
+    }
+
+    #[test]
+    fn missing_response_returns_default_for_backend_and_id() {
+        let mut ui = UiSystem::default();
+        ui.publish_completed_responses(
+            UiBackend::Egui,
+            vec![(
+                42,
+                UiResponse {
+                    clicked: true,
+                    ..Default::default()
+                },
+            )],
+        );
+
+        assert_eq!(ui.response(UiBackend::Egui, 404), UiResponse::default());
+        assert_eq!(ui.response(UiBackend::DearImGui, 42), UiResponse::default());
+    }
+}