@bornengine/engine 0.4.16

package/native/tvos/metal-patched/src/types.rs

@@ -0,0 +1,90 @@
+// Copyright 2016 GFX developers
+//
+// Licensed under the Apache License, Version 2.0, <LICENSE-APACHE or
+// http://apache.org/licenses/LICENSE-2.0> or the MIT license <LICENSE-MIT or
+// http://opensource.org/licenses/MIT>, at your option. This file may not be
+// copied, modified, or distributed except according to those terms.
+
+use super::NSUInteger;
+use std::default::Default;
+
+/// See <https://developer.apple.com/documentation/metal/mtlorigin>
+#[repr(C)]
+#[derive(Copy, Clone, Debug, Eq, PartialEq, Hash, Default)]
+pub struct MTLOrigin {
+    pub x: NSUInteger,
+    pub y: NSUInteger,
+    pub z: NSUInteger,
+}
+
+/// See <https://developer.apple.com/documentation/metal/mtlsize>
+#[repr(C)]
+#[derive(Copy, Clone, Debug, Eq, PartialEq, Hash, Default)]
+pub struct MTLSize {
+    pub width: NSUInteger,
+    pub height: NSUInteger,
+    pub depth: NSUInteger,
+}
+
+impl MTLSize {
+    pub fn new(width: NSUInteger, height: NSUInteger, depth: NSUInteger) -> Self {
+        Self {
+            width,
+            height,
+            depth,
+        }
+    }
+}
+
+/// See <https://developer.apple.com/documentation/metal/mtlregion>
+#[repr(C)]
+#[derive(Copy, Clone, Debug, Eq, PartialEq, Hash, Default)]
+pub struct MTLRegion {
+    pub origin: MTLOrigin,
+    pub size: MTLSize,
+}
+
+impl MTLRegion {
+    #[inline]
+    pub fn new_1d(x: NSUInteger, width: NSUInteger) -> Self {
+        Self::new_2d(x, 0, width, 1)
+    }
+
+    #[inline]
+    pub fn new_2d(x: NSUInteger, y: NSUInteger, width: NSUInteger, height: NSUInteger) -> Self {
+        Self::new_3d(x, y, 0, width, height, 1)
+    }
+
+    #[inline]
+    pub fn new_3d(
+        x: NSUInteger,
+        y: NSUInteger,
+        z: NSUInteger,
+        width: NSUInteger,
+        height: NSUInteger,
+        depth: NSUInteger,
+    ) -> Self {
+        Self {
+            origin: MTLOrigin { x, y, z },
+            size: MTLSize {
+                width,
+                height,
+                depth,
+            },
+        }
+    }
+}
+
+/// See <https://developer.apple.com/documentation/metal/mtlsampleposition>
+#[repr(C)]
+#[derive(Copy, Clone, Debug, PartialEq, Default)]
+pub struct MTLSamplePosition {
+    pub x: f32,
+    pub y: f32,
+}
+
+#[repr(C)]
+#[derive(Copy, Clone, Debug, Eq, PartialEq, Hash, Default)]
+pub struct MTLResourceID {
+    pub _impl: u64,
+}

package/native/tvos/metal-patched/src/vertexdescriptor.rs

@@ -0,0 +1,250 @@
+// Copyright 2016 GFX developers
+//
+// Licensed under the Apache License, Version 2.0, <LICENSE-APACHE or
+// http://apache.org/licenses/LICENSE-2.0> or the MIT license <LICENSE-MIT or
+// http://opensource.org/licenses/MIT>, at your option. This file may not be
+// copied, modified, or distributed except according to those terms.
+
+use super::NSUInteger;
+
+/// See <https://developer.apple.com/documentation/metal/mtlvertexformat>
+#[repr(u64)]
+#[allow(non_camel_case_types)]
+#[derive(Copy, Clone, Debug, Eq, PartialEq, Hash)]
+pub enum MTLVertexFormat {
+    Invalid = 0,
+    UChar2 = 1,
+    UChar3 = 2,
+    UChar4 = 3,
+    Char2 = 4,
+    Char3 = 5,
+    Char4 = 6,
+    UChar2Normalized = 7,
+    UChar3Normalized = 8,
+    UChar4Normalized = 9,
+    Char2Normalized = 10,
+    Char3Normalized = 11,
+    Char4Normalized = 12,
+    UShort2 = 13,
+    UShort3 = 14,
+    UShort4 = 15,
+    Short2 = 16,
+    Short3 = 17,
+    Short4 = 18,
+    UShort2Normalized = 19,
+    UShort3Normalized = 20,
+    UShort4Normalized = 21,
+    Short2Normalized = 22,
+    Short3Normalized = 23,
+    Short4Normalized = 24,
+    Half2 = 25,
+    Half3 = 26,
+    Half4 = 27,
+    Float = 28,
+    Float2 = 29,
+    Float3 = 30,
+    Float4 = 31,
+    Int = 32,
+    Int2 = 33,
+    Int3 = 34,
+    Int4 = 35,
+    UInt = 36,
+    UInt2 = 37,
+    UInt3 = 38,
+    UInt4 = 39,
+    Int1010102Normalized = 40,
+    UInt1010102Normalized = 41,
+    UChar4Normalized_BGRA = 42,
+    UChar = 45,
+    Char = 46,
+    UCharNormalized = 47,
+    CharNormalized = 48,
+    UShort = 49,
+    Short = 50,
+    UShortNormalized = 51,
+    ShortNormalized = 52,
+    Half = 53,
+}
+
+/// See <https://developer.apple.com/documentation/metal/mtlvertexstepfunction>
+#[repr(u64)]
+#[derive(Copy, Clone, Debug, Eq, PartialEq, Hash)]
+pub enum MTLVertexStepFunction {
+    Constant = 0,
+    PerVertex = 1,
+    PerInstance = 2,
+    PerPatch = 3,
+    PerPatchControlPoint = 4,
+}
+
+/// See <https://developer.apple.com/documentation/metal/mtlvertexbufferlayoutdescriptor>
+pub enum MTLVertexBufferLayoutDescriptor {}
+
+foreign_obj_type! {
+    type CType = MTLVertexBufferLayoutDescriptor;
+    pub struct VertexBufferLayoutDescriptor;
+}
+
+impl VertexBufferLayoutDescriptor {
+    pub fn new() -> Self {
+        unsafe {
+            let class = class!(MTLVertexBufferLayoutDescriptor);
+            msg_send![class, new]
+        }
+    }
+}
+
+impl VertexBufferLayoutDescriptorRef {
+    pub fn stride(&self) -> NSUInteger {
+        unsafe { msg_send![self, stride] }
+    }
+
+    pub fn set_stride(&self, stride: NSUInteger) {
+        unsafe { msg_send![self, setStride: stride] }
+    }
+
+    pub fn step_function(&self) -> MTLVertexStepFunction {
+        unsafe { msg_send![self, stepFunction] }
+    }
+
+    pub fn set_step_function(&self, func: MTLVertexStepFunction) {
+        unsafe { msg_send![self, setStepFunction: func] }
+    }
+
+    pub fn step_rate(&self) -> NSUInteger {
+        unsafe { msg_send![self, stepRate] }
+    }
+
+    pub fn set_step_rate(&self, step_rate: NSUInteger) {
+        unsafe { msg_send![self, setStepRate: step_rate] }
+    }
+}
+
+/// See <https://developer.apple.com/documentation/metal/mtlvertexbufferlayoutdescriptorarray>
+pub enum MTLVertexBufferLayoutDescriptorArray {}
+
+foreign_obj_type! {
+    type CType = MTLVertexBufferLayoutDescriptorArray;
+    pub struct VertexBufferLayoutDescriptorArray;
+}
+
+impl VertexBufferLayoutDescriptorArrayRef {
+    pub fn object_at(&self, index: NSUInteger) -> Option<&VertexBufferLayoutDescriptorRef> {
+        unsafe { msg_send![self, objectAtIndexedSubscript: index] }
+    }
+
+    pub fn set_object_at(
+        &self,
+        index: NSUInteger,
+        layout: Option<&VertexBufferLayoutDescriptorRef>,
+    ) {
+        unsafe {
+            msg_send![self, setObject:layout
+                   atIndexedSubscript:index]
+        }
+    }
+}
+
+/// See <https://developer.apple.com/documentation/metal/mtlvertexattributedescriptor>
+pub enum MTLVertexAttributeDescriptor {}
+
+foreign_obj_type! {
+    type CType = MTLVertexAttributeDescriptor;
+    pub struct VertexAttributeDescriptor;
+}
+
+impl VertexAttributeDescriptor {
+    pub fn new() -> Self {
+        unsafe {
+            let class = class!(MTLVertexAttributeDescriptor);
+            msg_send![class, new]
+        }
+    }
+}
+
+impl VertexAttributeDescriptorRef {
+    pub fn format(&self) -> MTLVertexFormat {
+        unsafe { msg_send![self, format] }
+    }
+
+    pub fn set_format(&self, format: MTLVertexFormat) {
+        unsafe { msg_send![self, setFormat: format] }
+    }
+
+    pub fn offset(&self) -> NSUInteger {
+        unsafe { msg_send![self, offset] }
+    }
+
+    pub fn set_offset(&self, offset: NSUInteger) {
+        unsafe { msg_send![self, setOffset: offset] }
+    }
+
+    pub fn buffer_index(&self) -> NSUInteger {
+        unsafe { msg_send![self, bufferIndex] }
+    }
+
+    pub fn set_buffer_index(&self, index: NSUInteger) {
+        unsafe { msg_send![self, setBufferIndex: index] }
+    }
+}
+
+/// See <https://developer.apple.com/documentation/metal/mtlvertexattributedescriptorarray>
+pub enum MTLVertexAttributeDescriptorArray {}
+
+foreign_obj_type! {
+    type CType = MTLVertexAttributeDescriptorArray;
+    pub struct VertexAttributeDescriptorArray;
+}
+
+impl VertexAttributeDescriptorArrayRef {
+    pub fn object_at(&self, index: NSUInteger) -> Option<&VertexAttributeDescriptorRef> {
+        unsafe { msg_send![self, objectAtIndexedSubscript: index] }
+    }
+
+    pub fn set_object_at(
+        &self,
+        index: NSUInteger,
+        attribute: Option<&VertexAttributeDescriptorRef>,
+    ) {
+        unsafe {
+            msg_send![self, setObject:attribute
+                   atIndexedSubscript:index]
+        }
+    }
+}
+
+/// See <https://developer.apple.com/documentation/metal/mtlvertexdescriptor>
+pub enum MTLVertexDescriptor {}
+
+foreign_obj_type! {
+    type CType = MTLVertexDescriptor;
+    pub struct VertexDescriptor;
+}
+
+impl VertexDescriptor {
+    pub fn new<'a>() -> &'a VertexDescriptorRef {
+        unsafe {
+            let class = class!(MTLVertexDescriptor);
+            msg_send![class, vertexDescriptor]
+        }
+    }
+}
+
+impl VertexDescriptorRef {
+    pub fn layouts(&self) -> &VertexBufferLayoutDescriptorArrayRef {
+        unsafe { msg_send![self, layouts] }
+    }
+
+    pub fn attributes(&self) -> &VertexAttributeDescriptorArrayRef {
+        unsafe { msg_send![self, attributes] }
+    }
+
+    #[cfg(feature = "private")]
+    pub unsafe fn serialize_descriptor(&self) -> *mut std::ffi::c_void {
+        msg_send![self, newSerializedDescriptor]
+    }
+
+    pub fn reset(&self) {
+        unsafe { msg_send![self, reset] }
+    }
+}

package/native/tvos/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);
+        }
+    }
+}