@bornengine/engine 0.4.16

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

@@ -0,0 +1,234 @@
+//! Keyboard, mouse, touch, and gamepad state (single-pad InputState model).
+//!
+//! Section of [`define_core_ffi!`](crate::define_core_ffi) — see
+//! `ffi_core/mod.rs` for the architecture and the invoking-crate contract.
+//! Internal: platform crates must invoke `define_core_ffi!()`, never the
+//! section macros directly.
+
+#[doc(hidden)]
+#[macro_export]
+macro_rules! __bloom_ffi_input {
+    () => {
+
+        // bloom_is_key_pressed  [source: macos]
+        #[no_mangle]
+        pub extern "C" fn bloom_is_key_pressed(key: f64) -> f64 {
+            $crate::ffi::guard("bloom_is_key_pressed", move || {
+                if engine().input.is_key_pressed(key as usize) { 1.0 } else { 0.0 }
+        })
+        }
+
+        // bloom_is_key_down  [source: macos]
+        #[no_mangle]
+        pub extern "C" fn bloom_is_key_down(key: f64) -> f64 {
+            $crate::ffi::guard("bloom_is_key_down", move || {
+                if engine().input.is_key_down(key as usize) { 1.0 } else { 0.0 }
+        })
+        }
+
+        // bloom_is_key_released  [source: macos]
+        #[no_mangle]
+        pub extern "C" fn bloom_is_key_released(key: f64) -> f64 {
+            $crate::ffi::guard("bloom_is_key_released", move || {
+                if engine().input.is_key_released(key as usize) { 1.0 } else { 0.0 }
+        })
+        }
+
+        // bloom_is_key_repeated — OS auto-repeat as its own edge. isKeyPressed
+        // stays initial-press-only (a held jump key must not machine-gun);
+        // caret navigation in text fields is the consumer.
+        #[no_mangle]
+        pub extern "C" fn bloom_is_key_repeated(key: f64) -> f64 {
+            $crate::ffi::guard("bloom_is_key_repeated", move || {
+                if engine().input.is_key_repeated(key as usize) { 1.0 } else { 0.0 }
+        })
+        }
+
+        // bloom_get_mouse_x  [source: macos]
+        #[no_mangle]
+        pub extern "C" fn bloom_get_mouse_x() -> f64 {
+            $crate::ffi::guard("bloom_get_mouse_x", move || {
+                engine().input.mouse_x
+        })
+        }
+
+        // bloom_get_mouse_y  [source: macos]
+        #[no_mangle]
+        pub extern "C" fn bloom_get_mouse_y() -> f64 {
+            $crate::ffi::guard("bloom_get_mouse_y", move || {
+                engine().input.mouse_y
+        })
+        }
+
+        // bloom_is_mouse_button_pressed  [source: macos]
+        #[no_mangle]
+        pub extern "C" fn bloom_is_mouse_button_pressed(btn: f64) -> f64 {
+            $crate::ffi::guard("bloom_is_mouse_button_pressed", move || {
+                if engine().input.is_mouse_button_pressed(btn as usize) { 1.0 } else { 0.0 }
+        })
+        }
+
+        // bloom_is_mouse_button_down  [source: macos]
+        #[no_mangle]
+        pub extern "C" fn bloom_is_mouse_button_down(btn: f64) -> f64 {
+            $crate::ffi::guard("bloom_is_mouse_button_down", move || {
+                if engine().input.is_mouse_button_down(btn as usize) { 1.0 } else { 0.0 }
+        })
+        }
+
+        // bloom_is_mouse_button_released  [source: macos]
+        #[no_mangle]
+        pub extern "C" fn bloom_is_mouse_button_released(btn: f64) -> f64 {
+            $crate::ffi::guard("bloom_is_mouse_button_released", move || {
+                if engine().input.is_mouse_button_released(btn as usize) { 1.0 } else { 0.0 }
+        })
+        }
+
+        // bloom_get_crown_rotation  [source: macos]
+        #[no_mangle]
+        pub extern "C" fn bloom_get_crown_rotation() -> f64 {
+            $crate::ffi::guard("bloom_get_crown_rotation", move || {
+                engine().input.consume_crown_rotation()
+        })
+        }
+
+        // bloom_is_gamepad_available  [source: macos]
+        #[no_mangle]
+        pub extern "C" fn bloom_is_gamepad_available() -> f64 {
+            $crate::ffi::guard("bloom_is_gamepad_available", move || {
+                if engine().input.is_gamepad_available() { 1.0 } else { 0.0 }
+        })
+        }
+
+        // bloom_get_gamepad_axis  [source: macos]
+        #[no_mangle]
+        pub extern "C" fn bloom_get_gamepad_axis(axis: f64) -> f64 {
+            $crate::ffi::guard("bloom_get_gamepad_axis", move || {
+                engine().input.get_gamepad_axis(axis as usize) as f64
+        })
+        }
+
+        // bloom_gamepad_rumble  [EN-031]
+        // low/high motor 0..1, duration in seconds. The platform's input poll
+        // consumes this and drives its own vibration API; on platforms with no
+        // vibration it is simply ignored (the state is written, nobody reads
+        // it) — which is why the symbol exists everywhere and the behaviour
+        // does not have to.
+        #[no_mangle]
+        pub extern "C" fn bloom_gamepad_rumble(low: f64, high: f64, seconds: f64) {
+            $crate::ffi::guard("bloom_gamepad_rumble", move || {
+                let inp = &mut engine().input;
+                inp.rumble = [
+                    (low as f32).clamp(0.0, 1.0),
+                    (high as f32).clamp(0.0, 1.0),
+                    (seconds as f32).clamp(0.0, 10.0),
+                ];
+        })
+        }
+
+        // bloom_is_gamepad_button_pressed  [source: macos]
+        #[no_mangle]
+        pub extern "C" fn bloom_is_gamepad_button_pressed(btn: f64) -> f64 {
+            $crate::ffi::guard("bloom_is_gamepad_button_pressed", move || {
+                if engine().input.is_gamepad_button_pressed(btn as usize) { 1.0 } else { 0.0 }
+        })
+        }
+
+        // bloom_is_gamepad_button_down  [source: macos]
+        #[no_mangle]
+        pub extern "C" fn bloom_is_gamepad_button_down(btn: f64) -> f64 {
+            $crate::ffi::guard("bloom_is_gamepad_button_down", move || {
+                if engine().input.is_gamepad_button_down(btn as usize) { 1.0 } else { 0.0 }
+        })
+        }
+
+        // bloom_is_gamepad_button_released  [source: macos]
+        #[no_mangle]
+        pub extern "C" fn bloom_is_gamepad_button_released(btn: f64) -> f64 {
+            $crate::ffi::guard("bloom_is_gamepad_button_released", move || {
+                if engine().input.is_gamepad_button_released(btn as usize) { 1.0 } else { 0.0 }
+        })
+        }
+
+        // bloom_get_gamepad_axis_count  [source: macos]
+        #[no_mangle]
+        pub extern "C" fn bloom_get_gamepad_axis_count() -> f64 {
+            $crate::ffi::guard("bloom_get_gamepad_axis_count", move || {
+                engine().input.get_gamepad_axis_count() as f64
+        })
+        }
+
+        // bloom_get_mouse_delta_x  [source: macos]
+        #[no_mangle]
+        pub extern "C" fn bloom_get_mouse_delta_x() -> f64 {
+            $crate::ffi::guard("bloom_get_mouse_delta_x", move || {
+                engine().input.mouse_delta_x
+        })
+        }
+
+        // bloom_get_mouse_delta_y  [source: macos]
+        #[no_mangle]
+        pub extern "C" fn bloom_get_mouse_delta_y() -> f64 {
+            $crate::ffi::guard("bloom_get_mouse_delta_y", move || {
+                engine().input.mouse_delta_y
+        })
+        }
+
+        // bloom_get_mouse_wheel  [source: macos]
+        #[no_mangle]
+        pub extern "C" fn bloom_get_mouse_wheel() -> f64 {
+            $crate::ffi::guard("bloom_get_mouse_wheel", move || {
+                engine().input.consume_mouse_wheel()
+        })
+        }
+
+        // bloom_get_char_pressed  [source: macos]
+        #[no_mangle]
+        pub extern "C" fn bloom_get_char_pressed() -> f64 {
+            $crate::ffi::guard("bloom_get_char_pressed", move || {
+                engine().input.pop_char() as f64
+        })
+        }
+
+        // bloom_get_touch_x  [source: macos]
+        #[no_mangle]
+        pub extern "C" fn bloom_get_touch_x(index: f64) -> f64 {
+            $crate::ffi::guard("bloom_get_touch_x", move || {
+                engine().input.get_touch_x(index as usize)
+        })
+        }
+
+        // bloom_get_touch_y  [source: macos]
+        #[no_mangle]
+        pub extern "C" fn bloom_get_touch_y(index: f64) -> f64 {
+            $crate::ffi::guard("bloom_get_touch_y", move || {
+                engine().input.get_touch_y(index as usize)
+        })
+        }
+
+        // bloom_get_touch_count  [source: macos]
+        #[no_mangle]
+        pub extern "C" fn bloom_get_touch_count() -> f64 {
+            $crate::ffi::guard("bloom_get_touch_count", move || {
+                engine().input.get_touch_count() as f64
+        })
+        }
+
+        // bloom_is_touch_active  [source: macos]
+        #[no_mangle]
+        pub extern "C" fn bloom_is_touch_active(index: f64) -> f64 {
+            $crate::ffi::guard("bloom_is_touch_active", move || {
+                if engine().input.is_touch_active(index as usize) { 1.0 } else { 0.0 }
+        })
+        }
+
+        // bloom_get_max_touch_points  [source: macos]
+        #[no_mangle]
+        pub extern "C" fn bloom_get_max_touch_points() -> f64 {
+            $crate::ffi::guard("bloom_get_max_touch_points", move || {
+                engine().input.max_touch_points() as f64
+        })
+        }
+
+    };
+}

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

@@ -0,0 +1,127 @@
+//! `define_core_ffi!` — the shared, non-physics `bloom_*` FFI surface.
+//!
+//! # Why this exists
+//!
+//! Every platform crate must export the full FFI surface declared in
+//! `package.json` (`perry.nativeLibrary.functions`); a missing symbol is a
+//! link error or dlopen crash in shipped games. Before this macro the ~250
+//! non-physics functions were hand-copied into six platform crates
+//! (~9,000 duplicated lines) and drifted constantly:
+//!
+//!   - Android shipped 60 functions behind (dlopen crash, PR #59), then
+//!     "fixed" part of the gap with silent no-op stubs.
+//!   - Windows stubbed the entire scene-graph / lighting / picking /
+//!     post-FX surface with silent no-ops.
+//!   - iOS/tvOS declared gamepad functions with an extra leading
+//!     `gamepad` parameter the manifest doesn't have, so every axis and
+//!     button read was off by one argument register.
+//!   - `bloom_create_mesh` / `bloom_gen_mesh_spline_ribbon` read `*const
+//!     f32` on some platforms; Perry passes arrays as pointers to inline
+//!     f64 data (see perry-codegen `lower_call/extern_func.rs`), so those
+//!     reads were garbage.
+//!
+//! One macro, expanded once per platform crate, makes per-platform drift
+//! in this surface structurally impossible — the same fix the physics
+//! surface got with `define_physics_ffi!`. `tools/validate-ffi.js`
+//! cross-checks the macro, the platform crates, and package.json in CI.
+//!
+//! # Contract for the invoking crate
+//!
+//! The platform crate must define, before invoking the macro:
+//!
+//! ```ignore
+//! /// Engine-state accessor. It must provide exclusive mutable access to the
+//! /// state for the duration of each FFI operation. A platform can return a
+//! /// direct mutable reference or a synchronization guard.
+//! fn engine() -> impl std::ops::DerefMut<Target = bloom_shared::engine::EngineState> { ... }
+//!
+//! /// Asset-path resolver: identity on desktop; prepends the app asset
+//! /// dir on Android/iOS/tvOS where relative paths don't resolve.
+//! fn bloom_resolve_asset_path(path: &str) -> std::borrow::Cow<'_, str> { ... }
+//!
+//! bloom_shared::define_core_ffi!();
+//! ```
+//!
+//! Functions NOT generated here (platform crates implement them by hand,
+//! validated by tools/validate-ffi.js): window + event loop
+//! (`bloom_init_window`, `bloom_begin/end_drawing`, ...), audio backend
+//! init/teardown, fullscreen, cursor capture, clipboard, file dialogs,
+//! window title/icon, `bloom_get_platform`, `bloom_get_language`.
+//!
+//! # Conventions inside the macro
+//!
+//!   - Every body is wrapped in [`crate::ffi::guard`] — panics log once
+//!     and return a default instead of crossing the C boundary.
+//!   - `models3d` / `image-extras` gated functions compile to a
+//!     once-warning stub when the feature is off. Symbols never silently
+//!     vanish and never silently no-op.
+//!   - String params are Perry StringHeader pointers
+//!     (`crate::string_header`); array params are pointers to inline f64
+//!     data (the compiler skips the 8-byte ArrayHeader at the callsite).
+
+mod game_loop;
+mod input;
+mod draw;
+mod assets;
+mod audio_ffi;
+mod models;
+mod scene;
+mod visual;
+mod vfx;
+mod ragdoll_ffi;
+
+/// Expand the full shared (non-physics) FFI surface. Composed from the
+/// per-subsystem section macros in this directory; platform crates invoke
+/// only this. Nested `$crate::__bloom_ffi_*` invocations expand at THIS
+/// macro's call site, so the `engine()` / `bloom_resolve_asset_path()`
+/// hooks still resolve in the invoking crate.
+#[macro_export]
+macro_rules! define_core_ffi {
+    () => {
+        $crate::__bloom_ffi_game_loop!();
+        $crate::__bloom_ffi_input!();
+        $crate::__bloom_ffi_draw!();
+        $crate::__bloom_ffi_assets!();
+        $crate::__bloom_ffi_audio_ffi!();
+        $crate::__bloom_ffi_models!();
+        $crate::__bloom_ffi_scene!();
+        $crate::__bloom_ffi_visual!();
+        $crate::__bloom_ffi_vfx!();
+        $crate::__bloom_ffi_ragdoll!();
+    };
+}
+
+
+// Compile-coverage for the macro body: expand it against mock hooks so
+// `cargo test -p bloom-shared` catches breakage without building any
+// platform crate. Nothing here runs — the hooks panic if called.
+#[cfg(all(test, not(target_arch = "wasm32")))]
+mod macro_expansion_compile_check {
+    #![allow(dead_code, unused_variables)]
+
+    struct EngineGuard(&'static mut crate::engine::EngineState);
+
+    impl std::ops::Deref for EngineGuard {
+        type Target = crate::engine::EngineState;
+
+        fn deref(&self) -> &Self::Target {
+            self.0
+        }
+    }
+
+    impl std::ops::DerefMut for EngineGuard {
+        fn deref_mut(&mut self) -> &mut Self::Target {
+            self.0
+        }
+    }
+
+    fn engine() -> EngineGuard {
+        unreachable!("compile-coverage mock — never called")
+    }
+
+    fn bloom_resolve_asset_path(path: &str) -> std::borrow::Cow<'_, str> {
+        std::borrow::Cow::Borrowed(path)
+    }
+
+    crate::define_core_ffi!();
+}