@bornengine/engine 0.4.16 → 0.5.1

package/native/ios/Cargo.toml

@@ -14,6 +14,8 @@ jolt = ["bloom-shared/jolt"]
 # unaffected; pure-2D games opt out via Perry feature forwarding.
 models3d = ["bloom-shared/models3d"]
 image-extras = ["bloom-shared/image-extras"]
+hot-reload = ["bloom-shared/hot-reload"]
+dev = ["hot-reload"]
 
 # Match perry-runtime's panic strategy so the final perry-driven link
 # doesn't see two copies of rust_eh_personality (and friends) from two

package/native/ios/src/lib.rs

@@ -1,10 +1,6 @@
-// `static mut` is intentional throughout this FFI surface — Perry calls
-// us from a single OS thread (the UIKit main run-loop), so the engine
-// singleton + view/window scratch state never race. The 2024 lint
-// flagging `&UI_VIEW`-style accesses is a real concern in
-// multi-threaded code, but inapplicable here. Suppress at the crate
-// root to avoid a dozen noise lines in every build. Mirrors
-// native/macos/src/lib.rs.
+// The iOS FFI uses legacy `static mut` state. UIKit text callbacks run on the
+// main thread while the game loop runs separately, so text/key events cross to
+// the game thread through the synchronized queue in `text_input`.
 #![allow(static_mut_refs)]
 
 use bloom_shared::engine::EngineState;
@@ -18,9 +14,11 @@ use objc2::{msg_send, sel};
 
 use raw_window_handle::{RawDisplayHandle, RawWindowHandle, UiKitDisplayHandle, UiKitWindowHandle};
 
-use std::ffi::c_void;
+use std::ffi::{c_void, CStr};
 use std::sync::OnceLock;
 
+mod text_input;
+
 static mut ENGINE: OnceLock<EngineState> = OnceLock::new();
 static mut UI_WINDOW: Option<Retained<AnyObject>> = None;
 static mut UI_VIEW: Option<Retained<AnyObject>> = None;
@@ -138,6 +136,30 @@ unsafe extern "C" fn bloom_touches_cancelled(_this: *mut c_void, _sel: Sel, touc
     handle_touches(touches, TouchPhase::Ended);
 }
 
+unsafe extern "C" fn bloom_can_become_first_responder(_this: *const c_void, _sel: Sel) -> Bool {
+    Bool::YES
+}
+
+unsafe extern "C" fn bloom_text_input_has_text(_this: *const c_void, _sel: Sel) -> Bool {
+    Bool::YES
+}
+
+unsafe extern "C" fn bloom_text_input_insert_text(
+    _this: *mut c_void,
+    _sel: Sel,
+    text: *const AnyObject,
+) {
+    if text.is_null() { return; }
+    let utf8: *const std::ffi::c_char = msg_send![text, UTF8String];
+    if utf8.is_null() { return; }
+    let text = CStr::from_ptr(utf8).to_string_lossy().into_owned();
+    text_input::enqueue(text_input::TextInputEvent::Insert(text));
+}
+
+unsafe extern "C" fn bloom_text_input_delete_backward(_this: *mut c_void, _sel: Sel) {
+    text_input::enqueue(text_input::TextInputEvent::DeleteBackward);
+}
+
 enum TouchPhase { Began, Moved, Ended }
 
 unsafe fn handle_touches(touches: *const AnyObject, phase: TouchPhase) {
@@ -226,6 +248,21 @@ fn register_metal_view_class() {
         class_addMethod(cls, sel!(touchesEnded:withEvent:), bloom_touches_ended as *const c_void, touch_types);
         class_addMethod(cls, sel!(touchesCancelled:withEvent:), bloom_touches_cancelled as *const c_void, touch_types);
 
+        extern "C" { fn objc_getProtocol(name: *const u8) -> *const c_void; }
+        let keyboard_protocol = objc_getProtocol(b"UIKeyInput\0".as_ptr());
+        if !keyboard_protocol.is_null() {
+            class_addProtocol(cls, keyboard_protocol);
+            class_addMethod(
+                cls,
+                sel!(canBecomeFirstResponder),
+                bloom_can_become_first_responder as *const c_void,
+                b"B16@0:8\0".as_ptr(),
+            );
+            class_addMethod(cls, sel!(hasText), bloom_text_input_has_text as *const c_void, b"B16@0:8\0".as_ptr());
+            class_addMethod(cls, sel!(insertText:), bloom_text_input_insert_text as *const c_void, b"v24@0:8@16\0".as_ptr());
+            class_addMethod(cls, sel!(deleteBackward), bloom_text_input_delete_backward as *const c_void, b"v16@0:8\0".as_ptr());
+        }
+
         objc_registerClassPair(cls);
     }
 }
@@ -890,6 +927,33 @@ pub extern "C" fn bloom_begin_drawing() {
     // No run loop pumping needed — UIApplicationMain handles the main run loop
     // on its own thread. The game runs on the game thread.
 
+    // UIKit text callbacks run on the main thread. Apply their queued events
+    // here so only the game thread mutates EngineState for text input.
+    for event in text_input::drain() {
+        let eng = engine();
+        match event {
+            text_input::TextInputEvent::Insert(text) => eng.input.push_ui_text(text),
+            text_input::TextInputEvent::DeleteBackward => {
+                eng.input.inject_key_down(8);
+                eng.input.inject_key_up(8);
+            }
+        }
+    }
+
+    // Apply UI text-focus transitions before beginning the next input snapshot.
+    match engine().ui.take_keyboard_request() {
+        Some(show) => unsafe {
+            if let Some(view) = &UI_VIEW {
+                let view_ptr = Retained::as_ptr(view);
+                let selector = if show { sel!(becomeFirstResponder) } else { sel!(resignFirstResponder) };
+                let _: () = msg_send![view_ptr, performSelectorOnMainThread: selector
+                    withObject: std::ptr::null::<AnyObject>()
+                    waitUntilDone: Bool::NO];
+            }
+        },
+        None => {}
+    }
+
     // Poll a connected controller before either begin_frame path below.
     poll_game_controllers();
 
@@ -1264,4 +1328,3 @@ fn bloom_jolt_ffi_physics() -> &'static mut bloom_shared::physics_jolt::JoltPhys
 
 #[cfg(feature = "jolt")]
 bloom_shared::define_physics_ffi!();
-

package/native/ios/src/text_input.rs

@@ -0,0 +1,48 @@
+use std::collections::VecDeque;
+use std::sync::{Mutex, MutexGuard, OnceLock};
+
+#[derive(Debug, Eq, PartialEq)]
+pub enum TextInputEvent {
+    Insert(String),
+    DeleteBackward,
+}
+
+static PENDING_EVENTS: OnceLock<Mutex<VecDeque<TextInputEvent>>> = OnceLock::new();
+
+fn pending_events() -> MutexGuard<'static, VecDeque<TextInputEvent>> {
+    PENDING_EVENTS
+        .get_or_init(|| Mutex::new(VecDeque::new()))
+        .lock()
+        .unwrap_or_else(std::sync::PoisonError::into_inner)
+}
+
+pub fn enqueue(event: TextInputEvent) {
+    pending_events().push_back(event);
+}
+
+pub fn drain() -> Vec<TextInputEvent> {
+    pending_events().drain(..).collect()
+}
+
+#[cfg(test)]
+mod tests {
+    use super::{drain, enqueue, TextInputEvent};
+
+    #[test]
+    fn text_events_cross_to_the_game_thread_once_and_in_order() {
+        let producer = std::thread::spawn(|| {
+            enqueue(TextInputEvent::Insert("é🙂".to_owned()));
+            enqueue(TextInputEvent::DeleteBackward);
+        });
+        producer.join().unwrap();
+
+        assert_eq!(
+            drain(),
+            [
+                TextInputEvent::Insert("é🙂".to_owned()),
+                TextInputEvent::DeleteBackward,
+            ]
+        );
+        assert!(drain().is_empty());
+    }
+}