@bornengine/engine 0.4.16 → 0.5.0

package/native/shared/Cargo.toml

@@ -25,12 +25,17 @@ models3d = ["dep:gltf", "dep:image_dds"]
 # beyond PNG" in the same sense as jpeg/bmp/tga (decode-only here; the
 # encoder lives in tools/bloom-cook).
 image-extras = ["image/jpeg", "image/bmp", "image/tga", "image/hdr", "dep:image_dds"]
+debug-ui = ["dep:imgui", "dep:imgui-wgpu"]
 
 [build-dependencies]
 cmake = "0.1"
 
 [dependencies]
 wgpu = "29"
+egui = "0.35"
+egui-wgpu = "0.35"
+imgui = { version = "0.12", optional = true, features = ["tables-api"] }
+imgui-wgpu = { version = "0.28", optional = true }
 raw-window-handle = "0.6"
 fontdue = "0.9"
 libc = "0.2"

package/native/shared/build.rs

@@ -53,6 +53,9 @@ fn build_jolt() {
     let from_source = std::env::var_os("BLOOM_JOLT_FROM_SOURCE").is_some();
     if !from_source {
         if let Some(prebuilt_dir) = find_prebuilt_dir(&manifest_dir, &target_os, &target_arch) {
+            if target_os == "windows" {
+                stage_windows_prebuilt_for_perry(&prebuilt_dir, &shim_dir, &target_arch);
+            }
             link_prebuilt(&prebuilt_dir, &target_os);
             emit_cxx_runtime_link(&target_os);
             return;
@@ -171,7 +174,12 @@ fn find_prebuilt_dir(
     } else {
         ""
     };
-    let target_token = format!("{}-{}{}", target_os, arch_token, sim_suffix);
+    let os_token = if target_os == "windows" {
+        "win32"
+    } else {
+        target_os
+    };
+    let target_token = format!("{}-{}{}", os_token, arch_token, sim_suffix);
 
     let candidates = std::iter::empty::<std::path::PathBuf>()
         .chain(
@@ -224,6 +232,38 @@ fn walk_up_for_node_modules(
     })
 }
 
+#[cfg(feature = "jolt")]
+fn stage_windows_prebuilt_for_perry(
+    prebuilt_dir: &std::path::Path,
+    shim_dir: &std::path::Path,
+    target_arch: &str,
+) {
+    let lib_dir = shim_dir
+        .join("build")
+        .join(format!("windows-{target_arch}"))
+        .join("lib");
+    std::fs::create_dir_all(&lib_dir)
+        .unwrap_or_else(|error| panic!("could not create {}: {error}", lib_dir.display()));
+    for name in ["bloom_jolt.lib", "Jolt.lib"] {
+        let source = prebuilt_dir.join(name);
+        let destination = lib_dir.join(name);
+        let same_file = source
+            .canonicalize()
+            .ok()
+            .zip(destination.canonicalize().ok())
+            .is_some_and(|(source, destination)| source == destination);
+        if !same_file {
+            std::fs::copy(&source, &destination).unwrap_or_else(|error| {
+                panic!(
+                    "could not stage {} to {}: {error}",
+                    source.display(),
+                    destination.display()
+                )
+            });
+        }
+    }
+}
+
 #[cfg(feature = "jolt")]
 fn link_prebuilt(dir: &std::path::Path, target_os: &str) {
     // Rerun if any archive in the prebuilt dir changes — covers the

package/native/shared/src/engine.rs

@@ -22,6 +22,7 @@ pub struct EngineState {
     pub renderer: Renderer,
     pub text: TextRenderer,
     pub input: InputState,
+    pub ui: crate::ui::UiSystem,
     pub audio: AudioMixer,
     pub textures: TextureManager,
     #[cfg(feature = "models3d")]
@@ -84,10 +85,18 @@ impl EngineState {
         // BLAS_INPUT cost only when it can be used.
         let mut scene = SceneGraph::new();
         scene.hw_rt_enabled = renderer.hw_rt_enabled;
+        let ui = crate::ui::UiSystem::default();
+        #[cfg(feature = "debug-ui")]
+        let renderer = {
+            let mut renderer = renderer;
+            renderer.init_dear_imgui();
+            renderer
+        };
         Self {
             renderer,
             text: TextRenderer::new(),
             input: InputState::new(),
+            ui,
             audio: AudioMixer::new(),
             textures: TextureManager::new(),
             #[cfg(feature = "models3d")]
@@ -162,6 +171,8 @@ impl EngineState {
         }
 
         self.input.begin_frame();
+        self.ui.begin_frame();
+        self.ui.set_input_snapshot(self.input.ui_snapshot());
         self.renderer.begin_frame();
         self.frame_count += 1;
     }
@@ -182,6 +193,37 @@ impl EngineState {
     }
 
     pub fn end_frame(&mut self) {
+        let logical_width = self.renderer.width().max(1) as f32;
+        let logical_height = self.renderer.height().max(1) as f32;
+        let pixels_per_point = self.renderer.physical_width() as f32 / logical_width;
+        let ui_frame = self.ui.evaluate_egui(
+            [0.0, 0.0, logical_width, logical_height],
+            pixels_per_point,
+            self.delta_time,
+        );
+        let native_texture_indices = ui_frame
+            .registered_textures
+            .values()
+            .filter_map(|&handle| {
+                self.textures
+                    .get(handle as f64)
+                    .map(|texture| (handle, texture.bind_group_idx))
+            })
+            .collect();
+        self.renderer
+            .set_egui_frame(ui_frame, native_texture_indices);
+
+        let debug_native_texture_indices = self
+            .ui
+            .registered_texture_handles(crate::ui::UiBackend::DearImGui)
+            .into_iter()
+            .filter_map(|handle| {
+                self.textures
+                    .get(handle as f64)
+                    .map(|texture| (handle, texture.bind_group_idx))
+            })
+            .collect();
+
         if self.direct_2d_mode {
             // Fast path for pure-2D games: render direct to the swapchain,
             // skipping scene prep, shadow maps, HDR/tonemap, SSAO, bloom,
@@ -190,7 +232,11 @@ impl EngineState {
             // when the scene graph is empty; this path typically hits
             // 60 fps on the same device.
             self.profiler.begin("render_total");
-            self.renderer.end_frame();
+            self.renderer.end_frame_with_ui(
+                &mut self.ui,
+                self.delta_time,
+                debug_native_texture_indices,
+            );
             self.profiler.end("render_total");
         } else {
             self.profiler.begin("scene_prepare");
@@ -233,7 +279,13 @@ impl EngineState {
             self.renderer.material_system_begin_frame(t, dt);
 
             self.profiler.begin("render_total");
-            self.renderer.end_frame_with_scene(&mut self.scene, &mut self.profiler);
+            self.renderer.end_frame_with_scene_ui(
+                &mut self.scene,
+                &mut self.profiler,
+                &mut self.ui,
+                self.delta_time,
+                debug_native_texture_indices,
+            );
             self.profiler.end("render_total");
         }
 

package/native/shared/src/ffi.rs

@@ -17,6 +17,9 @@
 //! Logging goes through [`log_error`], which writes to logcat on Android
 //! (stderr is discarded there) and stderr everywhere else.
 
+#[cfg(all(not(target_os = "android"), not(target_arch = "wasm32")))]
+use std::borrow::Cow;
+
 /// Default return value for an FFI function whose body panicked.
 pub trait FfiDefault {
     fn ffi_default() -> Self;
@@ -112,5 +115,55 @@ pub fn log_error(msg: &str) {
         return;
     }
     #[cfg(all(not(target_os = "android"), not(target_arch = "wasm32")))]
-    eprintln!("{msg}");
+    {
+        use std::io::IsTerminal;
+
+        let color_enabled = should_color_terminal_output(
+            std::io::stderr().is_terminal(),
+            std::env::var_os("NO_COLOR").is_some(),
+        );
+        eprintln!("{}", format_terminal_error(msg, color_enabled));
+    }
+}
+
+#[cfg(all(not(target_os = "android"), not(target_arch = "wasm32")))]
+fn should_color_terminal_output(stderr_is_terminal: bool, no_color_is_set: bool) -> bool {
+    stderr_is_terminal && !no_color_is_set
+}
+
+#[cfg(all(not(target_os = "android"), not(target_arch = "wasm32")))]
+fn format_terminal_error(msg: &str, color_enabled: bool) -> Cow<'_, str> {
+    if color_enabled {
+        Cow::Owned(format!("\x1b[31m{msg}\x1b[0m"))
+    } else {
+        Cow::Borrowed(msg)
+    }
+}
+
+#[cfg(all(test, not(target_os = "android"), not(target_arch = "wasm32")))]
+mod tests {
+    use super::{format_terminal_error, should_color_terminal_output};
+
+    #[test]
+    fn terminal_errors_are_red_and_reset_terminal_style() {
+        assert_eq!(
+            format_terminal_error("bloom: failure", true).as_ref(),
+            "\x1b[31mbloom: failure\x1b[0m"
+        );
+    }
+
+    #[test]
+    fn errors_remain_plain_when_color_is_disabled() {
+        assert_eq!(
+            format_terminal_error("bloom: failure", false).as_ref(),
+            "bloom: failure"
+        );
+    }
+
+    #[test]
+    fn color_is_only_enabled_for_tty_without_no_color() {
+        assert!(should_color_terminal_output(true, false));
+        assert!(!should_color_terminal_output(false, false));
+        assert!(!should_color_terminal_output(true, true));
+    }
 }

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

@@ -69,6 +69,7 @@ mod scene;
 mod visual;
 mod vfx;
 mod ragdoll_ffi;
+mod ui;
 
 /// Expand the full shared (non-physics) FFI surface. Composed from the
 /// per-subsystem section macros in this directory; platform crates invoke
@@ -88,6 +89,7 @@ macro_rules! define_core_ffi {
         $crate::__bloom_ffi_visual!();
         $crate::__bloom_ffi_vfx!();
         $crate::__bloom_ffi_ragdoll!();
+        $crate::__bloom_ffi_ui!();
     };
 }
 

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

@@ -0,0 +1,182 @@
+//! Typed UI command, input, response, and availability FFI.
+//!
+//! Section of [`define_core_ffi!`](crate::define_core_ffi) — see
+//! `ffi_core/mod.rs` for the architecture and the invoking-crate contract.
+
+#[doc(hidden)]
+#[macro_export]
+macro_rules! __bloom_ffi_ui {
+    () => {
+        #[no_mangle]
+        pub extern "C" fn bloom_ui_command(
+            backend: f64,
+            opcode: f64,
+            id: f64,
+            a: f64,
+            b: f64,
+            c: f64,
+            d: f64,
+            text_ptr: *const u8,
+        ) -> f64 {
+            $crate::ffi::guard("bloom_ui_command", move || {
+                let Some(backend) = $crate::ui::UiBackend::from_abi(backend) else {
+                    return 0.0;
+                };
+                let Some(opcode) = $crate::ui::UiOpcode::from_abi(opcode) else {
+                    return 0.0;
+                };
+                let Some(id) = $crate::ui::id_from_abi(id) else {
+                    return 0.0;
+                };
+                let text = $crate::string_header::str_from_header(text_ptr).to_owned();
+                let command = $crate::ui::UiCommand::new(backend, opcode, id, [a, b, c, d], text);
+                if engine().ui.queue_command(command) {
+                    1.0
+                } else {
+                    0.0
+                }
+            })
+        }
+
+        #[no_mangle]
+        pub extern "C" fn bloom_ui_scratch_reset(backend: f64) {
+            $crate::ffi::guard("bloom_ui_scratch_reset", move || {
+                let Some(backend) = $crate::ui::UiBackend::from_abi(backend) else {
+                    return;
+                };
+                engine().ui.reset_scratch(backend);
+            })
+        }
+
+        #[no_mangle]
+        pub extern "C" fn bloom_ui_scratch_push_f64(backend: f64, value: f64) {
+            $crate::ffi::guard("bloom_ui_scratch_push_f64", move || {
+                let Some(backend) = $crate::ui::UiBackend::from_abi(backend) else {
+                    return;
+                };
+                engine().ui.push_scratch(backend, value);
+            })
+        }
+
+        #[no_mangle]
+        pub extern "C" fn bloom_ui_scratch_command(
+            backend: f64,
+            opcode: f64,
+            id: f64,
+            count: f64,
+            text_ptr: *const u8,
+        ) -> f64 {
+            $crate::ffi::guard("bloom_ui_scratch_command", move || {
+                let Some(backend) = $crate::ui::UiBackend::from_abi(backend) else {
+                    return 0.0;
+                };
+                let Some(opcode) = $crate::ui::UiOpcode::from_abi(opcode) else {
+                    return 0.0;
+                };
+                let Some(id) = $crate::ui::id_from_abi(id) else {
+                    return 0.0;
+                };
+                let Some(count) = $crate::ui::id_from_abi(count) else {
+                    return 0.0;
+                };
+                let text = $crate::string_header::str_from_header(text_ptr).to_owned();
+                if engine()
+                    .ui
+                    .queue_scratch_command(backend, opcode, id, count as usize, text)
+                {
+                    1.0
+                } else {
+                    0.0
+                }
+            })
+        }
+
+        #[no_mangle]
+        pub extern "C" fn bloom_ui_inject_text(text_ptr: *const u8) {
+            $crate::ffi::guard("bloom_ui_inject_text", move || {
+                let text = $crate::string_header::str_from_header(text_ptr).to_owned();
+                engine().ui.inject_text(text);
+            })
+        }
+
+        #[no_mangle]
+        pub extern "C" fn bloom_ui_response(backend: f64, id: f64, field: f64) -> f64 {
+            $crate::ffi::guard("bloom_ui_response", move || {
+                let Some(backend) = $crate::ui::UiBackend::from_abi(backend) else {
+                    return 0.0;
+                };
+                let Some(id) = $crate::ui::id_from_abi(id) else {
+                    return 0.0;
+                };
+                let Some(field) = $crate::ui::id_from_abi(field) else {
+                    return 0.0;
+                };
+                let response = engine().ui.response(backend, id);
+                match field {
+                    0 => response.clicked as u8 as f64,
+                    1 => response.changed as u8 as f64,
+                    2 => response.hovered as u8 as f64,
+                    3 => response.focused as u8 as f64,
+                    4 => response.dragged as u8 as f64,
+                    5 => response.value,
+                    6 => engine().ui.has_response(backend, id) as u8 as f64,
+                    _ => 0.0,
+                }
+            })
+        }
+
+        #[no_mangle]
+        pub extern "C" fn bloom_ui_response_text(backend: f64, id: f64) -> *const u8 {
+            $crate::ffi::guard("bloom_ui_response_text", move || {
+                let Some(backend) = $crate::ui::UiBackend::from_abi(backend) else {
+                    return $crate::string_header::alloc_perry_string("");
+                };
+                let Some(id) = $crate::ui::id_from_abi(id) else {
+                    return $crate::string_header::alloc_perry_string("");
+                };
+                let text = engine().ui.response_text(backend, id);
+                $crate::string_header::alloc_perry_string(&text)
+            })
+        }
+
+        #[no_mangle]
+        pub extern "C" fn bloom_ui_is_available(backend: f64) -> f64 {
+            $crate::ffi::guard("bloom_ui_is_available", move || {
+                let Some(backend) = $crate::ui::UiBackend::from_abi(backend) else {
+                    return 0.0;
+                };
+                engine().ui.is_available(backend) as u8 as f64
+            })
+        }
+
+        #[no_mangle]
+        pub extern "C" fn bloom_ui_wants_input(backend: f64, kind: f64) -> f64 {
+            $crate::ffi::guard("bloom_ui_wants_input", move || {
+                let Some(backend) = $crate::ui::UiBackend::from_abi(backend) else {
+                    return 0.0;
+                };
+                let Some(kind) = $crate::ui::id_from_abi(kind) else {
+                    return 0.0;
+                };
+                engine().ui.wants_input(backend, kind) as u8 as f64
+            })
+        }
+
+        #[no_mangle]
+        pub extern "C" fn bloom_ui_take_keyboard_request(backend: f64) -> f64 {
+            $crate::ffi::guard("bloom_ui_take_keyboard_request", move || {
+                let Some(backend) = $crate::ui::UiBackend::from_abi(backend) else {
+                    return -1.0;
+                };
+                if backend != $crate::ui::UiBackend::Egui {
+                    return -1.0;
+                }
+                match engine().ui.take_keyboard_request() {
+                    Some(true) => 1.0,
+                    Some(false) => 0.0,
+                    None => -1.0,
+                }
+            })
+        }
+    };
+}