@bornengine/engine 0.4.16

package/native/visionos/Cargo.toml

@@ -0,0 +1,40 @@
+[package]
+name = "bloom-visionos"
+version = "0.1.0"
+edition = "2021"
+
+[lib]
+name = "bloom_visionos"
+crate-type = ["staticlib"]
+
+[features]
+default = ["jolt", "models3d", "image-extras"]
+jolt = ["bloom-shared/jolt"]
+# EN-014 — see native/shared/Cargo.toml. Default-on so existing games are
+# unaffected; pure-2D games opt out via Perry feature forwarding.
+models3d = ["bloom-shared/models3d"]
+image-extras = ["bloom-shared/image-extras"]
+
+# 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
+# independent Rust staticlibs. ld64.lld flags these as duplicate symbols;
+# GNU ld silently tolerates them, which is why only Apple targets break.
+# Mirrors the same setting in native/watchos/Cargo.toml.
+[profile.release]
+panic = "abort"
+
+[dependencies]
+bloom-shared = { path = "../shared", default-features = false, features = ["mp3"] }
+objc2 = "0.6"
+objc2-foundation = { version = "0.3", features = ["NSDate", "NSRunLoop", "NSString", "NSThread", "NSObject", "NSLocale", "NSArray"] }
+raw-window-handle = "0.6"
+wgpu = "29"
+# Needed by bloom_set_env_clear_from_hdr (HDR env-map decode); mirrors macOS.
+image = { version = "0.25", default-features = false, features = ["hdr"] }
+
+[patch.crates-io]
+# visionOS shares tvOS's vendored Metal crate (it already carries the
+# target_os = "visionos" cfg arms). Referenced as a sibling to avoid
+# duplicating the large vendored crate; the published package ships
+# native/tvos/metal-patched, so this relative path resolves there too.
+metal = { path = "../tvos/metal-patched" }

package/native/visionos/src/audio_backend.rs

@@ -0,0 +1,197 @@
+//! CoreAudio (RemoteIO) backend for tvOS: AudioUnit FFI bindings, the
+//! render callback, and the bloom_init_audio / bloom_close_audio entry
+//! points. The render callback owns the engine's AudioRenderer (handed
+//! off via AudioMixer::take_renderer) — see native/shared/src/audio for
+//! the threading contract.
+
+use crate::engine;
+use std::ffi::c_void;
+
+// CoreAudio (iOS) — RemoteIO Audio Unit
+// ============================================================
+
+type AudioUnit = *mut c_void;
+type OSStatus = i32;
+type AudioUnitPropertyID = u32;
+type AudioUnitScope = u32;
+type AudioUnitElement = u32;
+
+#[repr(C)]
+#[derive(Clone, Copy)]
+struct AudioComponentDescription {
+    component_type: u32,
+    component_sub_type: u32,
+    component_manufacturer: u32,
+    component_flags: u32,
+    component_flags_mask: u32,
+}
+
+#[repr(C)]
+#[derive(Clone, Copy)]
+struct AudioStreamBasicDescription {
+    sample_rate: f64,
+    format_id: u32,
+    format_flags: u32,
+    bytes_per_packet: u32,
+    frames_per_packet: u32,
+    bytes_per_frame: u32,
+    channels_per_frame: u32,
+    bits_per_channel: u32,
+    reserved: u32,
+}
+
+#[repr(C)]
+struct AudioBufferList {
+    number_buffers: u32,
+    buffers: [AudioBufferData; 1],
+}
+
+#[repr(C)]
+struct AudioBufferData {
+    number_channels: u32,
+    data_byte_size: u32,
+    data: *mut c_void,
+}
+
+type AURenderCallback = unsafe extern "C" fn(
+    in_ref_con: *mut c_void,
+    io_action_flags: *mut u32,
+    in_time_stamp: *const c_void,
+    in_bus_number: u32,
+    in_number_frames: u32,
+    io_data: *mut AudioBufferList,
+) -> OSStatus;
+
+#[repr(C)]
+struct AURenderCallbackStruct {
+    input_proc: AURenderCallback,
+    input_proc_ref_con: *mut c_void,
+}
+
+type AudioComponent = *mut c_void;
+
+#[link(name = "AudioToolbox", kind = "framework")]
+extern "C" {
+    fn AudioComponentFindNext(component: AudioComponent, desc: *const AudioComponentDescription) -> AudioComponent;
+    fn AudioComponentInstanceNew(component: AudioComponent, out: *mut AudioUnit) -> OSStatus;
+    fn AudioUnitSetProperty(
+        unit: AudioUnit,
+        property_id: AudioUnitPropertyID,
+        scope: AudioUnitScope,
+        element: AudioUnitElement,
+        data: *const c_void,
+        data_size: u32,
+    ) -> OSStatus;
+    fn AudioUnitInitialize(unit: AudioUnit) -> OSStatus;
+    fn AudioOutputUnitStart(unit: AudioUnit) -> OSStatus;
+    fn AudioOutputUnitStop(unit: AudioUnit) -> OSStatus;
+    fn AudioComponentInstanceDispose(unit: AudioUnit) -> OSStatus;
+}
+
+const K_AUDIO_UNIT_TYPE_OUTPUT: u32 = u32::from_be_bytes(*b"auou");
+const K_AUDIO_UNIT_SUB_TYPE_REMOTE_IO: u32 = u32::from_be_bytes(*b"rioc");
+const K_AUDIO_UNIT_MANUFACTURER_APPLE: u32 = u32::from_be_bytes(*b"appl");
+
+const K_AUDIO_UNIT_PROPERTY_STREAM_FORMAT: AudioUnitPropertyID = 8;
+const K_AUDIO_UNIT_PROPERTY_SET_RENDER_CALLBACK: AudioUnitPropertyID = 23;
+const K_AUDIO_UNIT_SCOPE_INPUT: AudioUnitScope = 1;
+
+const K_AUDIO_FORMAT_LINEAR_PCM: u32 = u32::from_be_bytes(*b"lpcm");
+const K_AUDIO_FORMAT_FLAG_IS_FLOAT: u32 = 1;
+const K_AUDIO_FORMAT_FLAG_IS_PACKED: u32 = 8;
+
+struct AudioUnitInstance { unit: AudioUnit }
+unsafe impl Send for AudioUnitInstance {}
+unsafe impl Sync for AudioUnitInstance {}
+
+static mut AUDIO_UNIT: Option<AudioUnitInstance> = None;
+// Render half of the audio system — owned by the CoreAudio render thread
+// after bloom_init_audio hands it off via AudioMixer::take_renderer.
+// See native/shared/src/audio/mod.rs for the threading contract.
+static mut AUDIO_RENDERER: Option<bloom_shared::audio::AudioRenderer> = None;
+
+unsafe extern "C" fn audio_render_callback(
+    _in_ref_con: *mut c_void,
+    _io_action_flags: *mut u32,
+    _in_time_stamp: *const c_void,
+    _in_bus_number: u32,
+    in_number_frames: u32,
+    io_data: *mut AudioBufferList,
+) -> OSStatus {
+    let buffer_list = &mut *io_data;
+    let buffer = &mut buffer_list.buffers[0];
+    let num_samples = in_number_frames as usize * 2;
+    let output = std::slice::from_raw_parts_mut(buffer.data as *mut f32, num_samples);
+    match AUDIO_RENDERER.as_mut() {
+        Some(r) => r.mix(output),
+        None => output.iter_mut().for_each(|s| *s = 0.0),
+    }
+    0
+}
+
+#[no_mangle]
+pub extern "C" fn bloom_init_audio() {
+    unsafe {
+        // Hand the render half to the audio thread before the callback
+        // can fire. Idempotent: a second init keeps the existing renderer.
+        if AUDIO_RENDERER.is_none() {
+            AUDIO_RENDERER = engine().audio.take_renderer();
+        }
+        let desc = AudioComponentDescription {
+            component_type: K_AUDIO_UNIT_TYPE_OUTPUT,
+            component_sub_type: K_AUDIO_UNIT_SUB_TYPE_REMOTE_IO,
+            component_manufacturer: K_AUDIO_UNIT_MANUFACTURER_APPLE,
+            component_flags: 0,
+            component_flags_mask: 0,
+        };
+
+        let component = AudioComponentFindNext(std::ptr::null_mut(), &desc);
+        if component.is_null() { return; }
+
+        let mut unit: AudioUnit = std::ptr::null_mut();
+        if AudioComponentInstanceNew(component, &mut unit) != 0 { return; }
+
+        let stream_desc = AudioStreamBasicDescription {
+            sample_rate: 44100.0,
+            format_id: K_AUDIO_FORMAT_LINEAR_PCM,
+            format_flags: K_AUDIO_FORMAT_FLAG_IS_FLOAT | K_AUDIO_FORMAT_FLAG_IS_PACKED,
+            bytes_per_packet: 8,
+            frames_per_packet: 1,
+            bytes_per_frame: 8,
+            channels_per_frame: 2,
+            bits_per_channel: 32,
+            reserved: 0,
+        };
+
+        AudioUnitSetProperty(
+            unit, K_AUDIO_UNIT_PROPERTY_STREAM_FORMAT, K_AUDIO_UNIT_SCOPE_INPUT, 0,
+            &stream_desc as *const _ as *const c_void,
+            std::mem::size_of::<AudioStreamBasicDescription>() as u32,
+        );
+
+        let callback_struct = AURenderCallbackStruct {
+            input_proc: audio_render_callback,
+            input_proc_ref_con: std::ptr::null_mut(),
+        };
+
+        AudioUnitSetProperty(
+            unit, K_AUDIO_UNIT_PROPERTY_SET_RENDER_CALLBACK, K_AUDIO_UNIT_SCOPE_INPUT, 0,
+            &callback_struct as *const _ as *const c_void,
+            std::mem::size_of::<AURenderCallbackStruct>() as u32,
+        );
+
+        AudioUnitInitialize(unit);
+        AudioOutputUnitStart(unit);
+        AUDIO_UNIT = Some(AudioUnitInstance { unit });
+    }
+}
+
+#[no_mangle]
+pub extern "C" fn bloom_close_audio() {
+    unsafe {
+        if let Some(au) = AUDIO_UNIT.take() {
+            AudioOutputUnitStop(au.unit);
+            AudioComponentInstanceDispose(au.unit);
+        }
+    }
+}