@bornengine/engine 0.4.16

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

@@ -0,0 +1,388 @@
+//! Texture/image/font/file loading, staging, screenshots.
+//!
+//! 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_assets {
+    () => {
+
+        // bloom_take_screenshot  [source: macos]
+        #[no_mangle]
+        pub extern "C" fn bloom_take_screenshot(path_ptr: *const u8) {
+            $crate::ffi::guard("bloom_take_screenshot", move || {
+                let path = $crate::string_header::str_from_header(path_ptr).to_string();
+                eprintln!("bloom: screenshot requested -> '{}'", path);
+                let mut eng = engine();
+                eng.renderer.screenshot_requested = true;
+                eng.renderer.pending_screenshot_path = Some(path);
+        })
+        }
+
+        // bloom_load_font  [source: macos]
+        #[no_mangle]
+        pub extern "C" fn bloom_load_font(path_ptr: *const u8, _size: f64) -> f64 {
+            $crate::ffi::guard("bloom_load_font", move || {
+                let path = $crate::string_header::str_from_header(path_ptr);
+                let path: &str = &bloom_resolve_asset_path(path);
+                match std::fs::read(path) {
+                    Ok(data) => engine().text.load_font(&data) as f64,
+                    Err(_) => 0.0,
+                }
+        })
+        }
+
+        // bloom_unload_font  [source: macos]
+        #[no_mangle]
+        pub extern "C" fn bloom_unload_font(font_handle: f64) {
+            $crate::ffi::guard("bloom_unload_font", move || {
+                engine().text.unload_font(font_handle as usize);
+        })
+        }
+
+        // bloom_load_sound  [source: curated]
+        #[no_mangle]
+        pub extern "C" fn bloom_load_sound(path_ptr: *const u8) -> f64 {
+            $crate::ffi::guard("bloom_load_sound", move || {
+                let path = $crate::string_header::str_from_header(path_ptr);
+                let path: &str = &bloom_resolve_asset_path(path);
+                match std::fs::read(path) {
+                    Ok(data) => match $crate::audio::decode_audio(path, &data) {
+                        Some(s) => engine().audio.load_sound(s),
+                        None => 0.0,
+                    },
+                    Err(_) => 0.0,
+                }
+        })
+        }
+
+        // bloom_load_texture  [source: curated]
+        #[no_mangle]
+        pub extern "C" fn bloom_load_texture(path_ptr: *const u8) -> f64 {
+            $crate::ffi::guard("bloom_load_texture", move || {
+                let path = $crate::string_header::str_from_header(path_ptr);
+                let path: &str = &bloom_resolve_asset_path(path);
+                match std::fs::read(path) {
+                    Ok(data) => {
+                        let mut eng = engine();
+                        let $crate::engine::EngineState { ref mut textures, ref mut renderer, .. } = *eng;
+                        textures.load_texture(renderer, &data)
+                    }
+                    Err(_) => 0.0,
+                }
+        })
+        }
+
+        // bloom_unload_texture  [source: curated]
+        #[no_mangle]
+        pub extern "C" fn bloom_unload_texture(handle: f64) {
+            $crate::ffi::guard("bloom_unload_texture", move || {
+                let mut eng = engine();
+                let $crate::engine::EngineState { ref mut textures, ref mut renderer, .. } = *eng;
+                textures.unload_texture(handle, renderer);
+        })
+        }
+
+        // bloom_get_texture_width  [source: macos]
+        #[no_mangle]
+        pub extern "C" fn bloom_get_texture_width(handle: f64) -> f64 {
+            $crate::ffi::guard("bloom_get_texture_width", move || {
+                let eng = engine();
+                eng.textures.get(handle).map(|t| t.width as f64).unwrap_or(0.0)
+        })
+        }
+
+        // bloom_get_texture_height  [source: macos]
+        #[no_mangle]
+        pub extern "C" fn bloom_get_texture_height(handle: f64) -> f64 {
+            $crate::ffi::guard("bloom_get_texture_height", move || {
+                let eng = engine();
+                eng.textures.get(handle).map(|t| t.height as f64).unwrap_or(0.0)
+        })
+        }
+
+        // bloom_load_image  [source: macos]
+        #[no_mangle]
+        pub extern "C" fn bloom_load_image(path_ptr: *const u8) -> f64 {
+            $crate::ffi::guard("bloom_load_image", move || {
+                let path = $crate::string_header::str_from_header(path_ptr);
+                let path: &str = &bloom_resolve_asset_path(path);
+                match std::fs::read(path) {
+                    Ok(data) => engine().textures.load_image(&data),
+                    Err(_) => 0.0,
+                }
+        })
+        }
+
+        // bloom_image_resize  [source: macos]
+        #[no_mangle]
+        pub extern "C" fn bloom_image_resize(handle: f64, w: f64, h: f64) {
+            $crate::ffi::guard("bloom_image_resize", move || {
+                engine().textures.image_resize(handle, w as u32, h as u32);
+        })
+        }
+
+        // bloom_image_crop  [source: macos]
+        #[no_mangle]
+        pub extern "C" fn bloom_image_crop(handle: f64, x: f64, y: f64, w: f64, h: f64) {
+            $crate::ffi::guard("bloom_image_crop", move || {
+                engine().textures.image_crop(handle, x as u32, y as u32, w as u32, h as u32);
+        })
+        }
+
+        // bloom_image_flip_h  [source: macos]
+        #[no_mangle]
+        pub extern "C" fn bloom_image_flip_h(handle: f64) {
+            $crate::ffi::guard("bloom_image_flip_h", move || {
+                engine().textures.image_flip_h(handle);
+        })
+        }
+
+        // bloom_image_flip_v  [source: macos]
+        #[no_mangle]
+        pub extern "C" fn bloom_image_flip_v(handle: f64) {
+            $crate::ffi::guard("bloom_image_flip_v", move || {
+                engine().textures.image_flip_v(handle);
+        })
+        }
+
+        // bloom_load_texture_from_image  [source: curated]
+        #[no_mangle]
+        pub extern "C" fn bloom_load_texture_from_image(handle: f64) -> f64 {
+            $crate::ffi::guard("bloom_load_texture_from_image", move || {
+                let mut eng = engine();
+                let $crate::engine::EngineState { ref mut textures, ref mut renderer, .. } = *eng;
+                textures.load_texture_from_image(handle, renderer)
+        })
+        }
+
+        // bloom_gen_texture_mipmaps  [source: macos]
+        #[no_mangle]
+        pub extern "C" fn bloom_gen_texture_mipmaps(_handle: f64) {
+            $crate::ffi::guard("bloom_gen_texture_mipmaps", move || {
+                // Mipmap generation is handled by the GPU texture creation pipeline
+                // This is a no-op for now as wgpu handles mipmaps internally
+        })
+        }
+
+        // bloom_load_shader  [source: macos]
+        #[no_mangle]
+        pub extern "C" fn bloom_load_shader(source_ptr: *const u8) -> f64 {
+            $crate::ffi::guard("bloom_load_shader", move || {
+                let source = $crate::string_header::str_from_header(source_ptr);
+                engine().renderer.load_custom_shader(source) as f64
+        })
+        }
+
+        // bloom_load_music  [source: curated]
+        #[no_mangle]
+        pub extern "C" fn bloom_load_music(path_ptr: *const u8) -> f64 {
+            $crate::ffi::guard("bloom_load_music", move || {
+                let path = $crate::string_header::str_from_header(path_ptr);
+                let path: &str = &bloom_resolve_asset_path(path);
+                match std::fs::read(path) {
+                    // Streams OGG/MP3 from the compressed bytes (background
+                    // decode worker); WAV and wasm32 fully decode.
+                    Ok(data) => engine().audio.load_music_bytes(path, data),
+                    Err(_) => 0.0,
+                }
+        })
+        }
+
+        // bloom_write_file  [source: macos]
+        #[no_mangle]
+        pub extern "C" fn bloom_write_file(path_ptr: *const u8, data_ptr: *const u8) -> f64 {
+            $crate::ffi::guard("bloom_write_file", move || {
+                let path = $crate::string_header::str_from_header(path_ptr);
+                let path: &str = &bloom_resolve_asset_path(path);
+                // A string that failed ABI validation must NOT be written as "" and
+                // reported as a success. That is not a save, it is a deletion with a
+                // thumbs-up, and it is exactly what happened to every world the
+                // editor ever saved.
+                let data = match $crate::string_header::try_str_from_header(data_ptr) {
+                    Some(d) => d,
+                    None => return 0.0,
+                };
+                match std::fs::write(path, data.as_bytes()) {
+                    Ok(_) => 1.0,
+                    Err(_) => 0.0,
+                }
+        })
+        }
+
+        // bloom_launch_process  [EN-048]
+        //
+        // Perry's `child_process.spawn` COMPILES and then does nothing — it returns a
+        // child with an undefined pid and no process is started. So a tool that wants
+        // to launch another program (the editor's play-in-editor: save the level, run
+        // the game on it) has nowhere to go.
+        //
+        // Fire-and-forget by design. The caller is a GUI that must not block on, or
+        // die with, the thing it launched: close the game, and you are back in the
+        // editor with your undo history intact.
+        //
+        // `args` is newline-separated. Not shell-escaped and not shell-interpreted —
+        // there is no shell here, which is also why there is nothing to inject into.
+        #[no_mangle]
+        pub extern "C" fn bloom_launch_process(
+            cmd_ptr: *const u8, args_ptr: *const u8, cwd_ptr: *const u8,
+        ) -> f64 {
+            $crate::ffi::guard("bloom_launch_process", move || {
+                let cmd = $crate::string_header::str_from_header(cmd_ptr);
+                if cmd.is_empty() { return 0.0; }
+                let args = $crate::string_header::str_from_header(args_ptr);
+                let cwd = $crate::string_header::str_from_header(cwd_ptr);
+
+                // Resolve the program against `cwd` when it is a bare name.
+                //
+                // Rust's `Command::current_dir` sets the CHILD's working directory --
+                // it does NOT affect how the program is FOUND, which happens in the
+                // parent's context. So launching "main.exe" with cwd "<project>"
+                // fails with "program not found" even though main.exe is sitting
+                // right there in <project>. Which is exactly what it did.
+                let bare = !cmd.chars().any(|ch| ch == '/' || ch == std::path::MAIN_SEPARATOR);
+                let resolved: std::path::PathBuf = if !cwd.is_empty() && bare {
+                    std::path::Path::new(cwd).join(cmd)
+                } else {
+                    std::path::PathBuf::from(cmd)
+                };
+                let mut c = std::process::Command::new(&resolved);
+                for a in args.split('\n') {
+                    if !a.is_empty() { c.arg(a); }
+                }
+                if !cwd.is_empty() { c.current_dir(cwd); }
+                // Detach: we never wait on it, and we do not want its output in ours.
+                c.stdin(std::process::Stdio::null())
+                 .stdout(std::process::Stdio::null())
+                 .stderr(std::process::Stdio::null());
+                let r = c.spawn();
+                match r {
+                    Ok(child) => child.id() as f64,
+                    Err(_) => 0.0,
+                }
+        })
+        }
+
+        // bloom_file_exists  [source: macos]
+        #[no_mangle]
+        pub extern "C" fn bloom_file_exists(path_ptr: *const u8) -> f64 {
+            $crate::ffi::guard("bloom_file_exists", move || {
+                let path = $crate::string_header::str_from_header(path_ptr);
+                let path: &str = &bloom_resolve_asset_path(path);
+                if std::path::Path::new(path).exists() { 1.0 } else { 0.0 }
+        })
+        }
+
+        // bloom_read_file  [source: curated]
+        #[no_mangle]
+        pub extern "C" fn bloom_read_file(path_ptr: *const u8) -> *const u8 {
+            $crate::ffi::guard("bloom_read_file", move || {
+                let path = $crate::string_header::str_from_header(path_ptr);
+                let path: &str = &bloom_resolve_asset_path(path);
+                match std::fs::read_to_string(path) {
+                    Ok(contents) => $crate::string_header::alloc_perry_string(&contents),
+                    Err(_) => $crate::string_header::alloc_perry_string(""),
+                }
+        })
+        }
+
+        // bloom_load_render_texture  [source: macos]
+        #[no_mangle]
+        pub extern "C" fn bloom_load_render_texture(width: f64, height: f64) -> f64 {
+            $crate::ffi::guard("bloom_load_render_texture", move || {
+                let w = width as u32;
+                let h = height as u32;
+                let mut eng = engine();
+                let rt_handle = eng.textures.load_render_texture(w, h);
+
+                // Create the GPU texture via the renderer's public method.
+                let (bind_group_idx, _tex_vec_idx) = eng.renderer.create_render_texture(w, h);
+
+                // Register as a texture handle so drawTexture can sample it.
+                let tex_handle = eng.textures.textures.alloc($crate::textures::TextureData {
+                    bind_group_idx, width: w, height: h,
+                });
+                eng.textures.set_render_texture_handle(rt_handle, tex_handle);
+
+                rt_handle
+        })
+        }
+
+        // bloom_unload_render_texture  [source: macos]
+        #[no_mangle]
+        pub extern "C" fn bloom_unload_render_texture(handle: f64) {
+            $crate::ffi::guard("bloom_unload_render_texture", move || {
+                engine().textures.unload_render_texture(handle);
+        })
+        }
+
+        // bloom_stage_texture  [source: macos]
+        #[no_mangle]
+        pub extern "C" fn bloom_stage_texture(path_ptr: *const u8) -> f64 {
+            $crate::ffi::guard("bloom_stage_texture", move || {
+                let path = $crate::string_header::str_from_header(path_ptr);
+                let path: &str = &bloom_resolve_asset_path(path);
+                match std::fs::read(path) {
+                    Ok(data) => $crate::staging::decode_and_stage_texture(&data),
+                    Err(_) => 0.0,
+                }
+        })
+        }
+
+        // bloom_stage_sound  [source: curated]
+        #[no_mangle]
+        pub extern "C" fn bloom_stage_sound(path_ptr: *const u8) -> f64 {
+            $crate::ffi::guard("bloom_stage_sound", move || {
+                let path = $crate::string_header::str_from_header(path_ptr);
+                let path: &str = &bloom_resolve_asset_path(path);
+                let data = match std::fs::read(path) { Ok(d) => d, Err(_) => return 0.0 };
+                match $crate::audio::decode_audio(path, &data) {
+                    Some(s) => $crate::staging::stage_sound(s),
+                    None => 0.0,
+                }
+        })
+        }
+
+        // bloom_commit_texture  [source: macos]
+        #[no_mangle]
+        pub extern "C" fn bloom_commit_texture(staging_handle: f64) -> f64 {
+            $crate::ffi::guard("bloom_commit_texture", move || {
+                let staged = match $crate::staging::take_texture(staging_handle) {
+                    Some(s) => s,
+                    None => return 0.0,
+                };
+                let mut eng = engine();
+                let bind_group_idx = eng.renderer.register_texture(staged.width, staged.height, &staged.data);
+                eng.textures.textures.alloc($crate::textures::TextureData {
+                    bind_group_idx, width: staged.width, height: staged.height,
+                })
+        })
+        }
+
+        // bloom_commit_sound  [source: macos]
+        #[no_mangle]
+        pub extern "C" fn bloom_commit_sound(staging_handle: f64) -> f64 {
+            $crate::ffi::guard("bloom_commit_sound", move || {
+                match $crate::staging::take_sound(staging_handle) {
+                    Some(sd) => engine().audio.load_sound(sd),
+                    None => 0.0,
+                }
+        })
+        }
+
+        // bloom_commit_music  [source: macos]
+        #[no_mangle]
+        pub extern "C" fn bloom_commit_music(staging_handle: f64) -> f64 {
+            $crate::ffi::guard("bloom_commit_music", move || {
+                match $crate::staging::take_sound(staging_handle) {
+                    Some(sd) => engine().audio.load_music(sd),
+                    None => 0.0,
+                }
+        })
+        }
+
+    };
+}

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

@@ -0,0 +1,184 @@
+//! Sound and music playback control.
+//!
+//! 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_audio_ffi {
+    () => {
+
+        // bloom_play_sound  [source: macos]
+        #[no_mangle]
+        pub extern "C" fn bloom_play_sound(handle: f64) {
+            $crate::ffi::guard("bloom_play_sound", move || {
+                engine().audio.play_sound(handle);
+        })
+        }
+
+        // bloom_stop_sound  [source: macos]
+        #[no_mangle]
+        pub extern "C" fn bloom_stop_sound(handle: f64) {
+            $crate::ffi::guard("bloom_stop_sound", move || {
+                engine().audio.stop_sound(handle);
+        })
+        }
+
+        // bloom_play_sound_3d  [source: macos]
+        #[no_mangle]
+        pub extern "C" fn bloom_play_sound_3d(handle: f64, x: f64, y: f64, z: f64) {
+            $crate::ffi::guard("bloom_play_sound_3d", move || {
+                engine().audio.play_sound_3d(handle, x as f32, y as f32, z as f32);
+        })
+        }
+
+        // bloom_play_music  [source: macos]
+        #[no_mangle]
+        pub extern "C" fn bloom_play_music(handle: f64) {
+            $crate::ffi::guard("bloom_play_music", move || {
+                engine().audio.play_music(handle);
+        })
+        }
+
+        // bloom_stop_music  [source: macos]
+        #[no_mangle]
+        pub extern "C" fn bloom_stop_music(handle: f64) {
+            $crate::ffi::guard("bloom_stop_music", move || {
+                engine().audio.stop_music(handle);
+        })
+        }
+
+        // bloom_is_music_playing  [source: macos]
+        #[no_mangle]
+        pub extern "C" fn bloom_is_music_playing(handle: f64) -> f64 {
+            $crate::ffi::guard("bloom_is_music_playing", move || {
+                if engine().audio.is_music_playing(handle) { 1.0 } else { 0.0 }
+        })
+        }
+
+        // ---- EN-029: buses, reverb send, occlusion low-pass -------------
+        //
+        // The mixer was master + per-voice gain and nothing else. These three
+        // additions are what separate "sounds are playing" from "the space
+        // sounds like a place": a bus you can duck, a tail you can send to, and
+        // a filter that makes a wall audible.
+
+        // bloom_set_sound_bus — 0 = SFX, 1 = music, 2 = UI.
+        #[no_mangle]
+        pub extern "C" fn bloom_set_sound_bus(handle: f64, bus: f64) {
+            $crate::ffi::guard("bloom_set_sound_bus", move || {
+                engine().audio.set_sound_bus(handle, bus as u8);
+        })
+        }
+
+        // bloom_set_sound_reverb_send — 0..1.
+        #[no_mangle]
+        pub extern "C" fn bloom_set_sound_reverb_send(handle: f64, send: f64) {
+            $crate::ffi::guard("bloom_set_sound_reverb_send", move || {
+                engine().audio.set_sound_reverb_send(handle, send as f32);
+        })
+        }
+
+        // bloom_set_sound_lowpass — cutoff Hz; 0 = bypass.
+        #[no_mangle]
+        pub extern "C" fn bloom_set_sound_lowpass(handle: f64, cutoff: f64) {
+            $crate::ffi::guard("bloom_set_sound_lowpass", move || {
+                engine().audio.set_sound_lowpass(handle, cutoff as f32);
+        })
+        }
+
+        // bloom_set_bus_gain
+        #[no_mangle]
+        pub extern "C" fn bloom_set_bus_gain(bus: f64, gain: f64) {
+            $crate::ffi::guard("bloom_set_bus_gain", move || {
+                engine().audio.set_bus_gain(bus as u8, gain as f32);
+        })
+        }
+
+        // bloom_duck_bus — momentary attenuation with attack/hold/release.
+        #[no_mangle]
+        pub extern "C" fn bloom_duck_bus(bus: f64, amount: f64, attack: f64, release: f64, hold: f64) {
+            $crate::ffi::guard("bloom_duck_bus", move || {
+                engine().audio.duck_bus(
+                    bus as u8, amount as f32, attack as f32, release as f32, hold as f32);
+        })
+        }
+
+        // bloom_set_reverb — size / damp / wet, all 0..1. wet = 0 bypasses the
+        // whole reverb path, so it costs nothing until a game asks for it.
+        #[no_mangle]
+        pub extern "C" fn bloom_set_reverb(size: f64, damp: f64, wet: f64) {
+            $crate::ffi::guard("bloom_set_reverb", move || {
+                engine().audio.set_reverb(size as f32, damp as f32, wet as f32);
+        })
+        }
+
+        // ---- EN-062: live spatial voices ---------------------------------
+        //
+        // bloom_play_sound_3d is fire-and-forget: it cannot loop and it cannot
+        // move. These six calls are the emitter API — a voice id you hold onto
+        // and steer. A river you walk along, wind in a treeline, a creature
+        // circling closer: all of them are one looping voice plus a per-frame
+        // position/volume ride.
+
+        // bloom_play_sound_3d_ex — returns the voice id (0 = unknown sound).
+        // looping != 0 loops until bloom_voice_stop. ref_dist = full-volume
+        // range, rolloff = fall-off steepness (1,1 == the classic 1/d),
+        // max_dist = cull range (<= 0 = never cull).
+        #[no_mangle]
+        pub extern "C" fn bloom_play_sound_3d_ex(
+            handle: f64, x: f64, y: f64, z: f64,
+            looping: f64, ref_dist: f64, max_dist: f64, rolloff: f64,
+        ) -> f64 {
+            $crate::ffi::guard("bloom_play_sound_3d_ex", move || {
+                engine().audio.play_sound_3d_ex(
+                    handle, x as f32, y as f32, z as f32,
+                    looping != 0.0, ref_dist as f32, max_dist as f32, rolloff as f32)
+        })
+        }
+
+        // bloom_voice_set_position — move a live voice (doppler falls out of
+        // the motion automatically).
+        #[no_mangle]
+        pub extern "C" fn bloom_voice_set_position(voice: f64, x: f64, y: f64, z: f64) {
+            $crate::ffi::guard("bloom_voice_set_position", move || {
+                engine().audio.set_voice_position(voice, x as f32, y as f32, z as f32);
+        })
+        }
+
+        // bloom_voice_stop — click-free: fades over one mix block, then drops.
+        #[no_mangle]
+        pub extern "C" fn bloom_voice_stop(voice: f64) {
+            $crate::ffi::guard("bloom_voice_stop", move || {
+                engine().audio.stop_voice(voice);
+        })
+        }
+
+        // bloom_voice_set_volume
+        #[no_mangle]
+        pub extern "C" fn bloom_voice_set_volume(voice: f64, volume: f64) {
+            $crate::ffi::guard("bloom_voice_set_volume", move || {
+                engine().audio.set_voice_volume(voice, volume as f32);
+        })
+        }
+
+        // bloom_voice_set_pitch — 0.25..4 playback-rate multiplier.
+        #[no_mangle]
+        pub extern "C" fn bloom_voice_set_pitch(voice: f64, pitch: f64) {
+            $crate::ffi::guard("bloom_voice_set_pitch", move || {
+                engine().audio.set_voice_pitch(voice, pitch as f32);
+        })
+        }
+
+        // bloom_voice_set_lowpass — per-VOICE occlusion (Hz; 0 = bypass).
+        #[no_mangle]
+        pub extern "C" fn bloom_voice_set_lowpass(voice: f64, cutoff: f64) {
+            $crate::ffi::guard("bloom_voice_set_lowpass", move || {
+                engine().audio.set_voice_lowpass(voice, cutoff as f32);
+        })
+        }
+
+    };
+}