fix macOS build

pxl8d/build.rs

@@ -50,6 +50,7 @@ fn main() {
         .blocklist_item("FP_ZERO")
         .blocklist_item("FP_SUBNORMAL")
         .blocklist_item("FP_NORMAL")
+        .clang_arg("-DPXL8_NO_SIMD")
         .use_core()
         .rustified_enum(".*")
         .generate()

pxl8d/src/allocator.rs

@@ -2,7 +2,7 @@ use core::alloc::{GlobalAlloc, Layout};
 
 pub struct Allocator;
 
-#[cfg(unix)]
+#[cfg(all(unix, not(target_os = "macos")))]
 unsafe impl GlobalAlloc for Allocator {
     unsafe fn alloc(&self, layout: Layout) -> *mut u8 {
         unsafe { libc::memalign(layout.align(), layout.size()) as *mut u8 }
@@ -17,6 +17,28 @@ unsafe impl GlobalAlloc for Allocator {
     }
 }
 
+#[cfg(target_os = "macos")]
+unsafe impl GlobalAlloc for Allocator {
+    unsafe fn alloc(&self, layout: Layout) -> *mut u8 {
+        let mut ptr: *mut libc::c_void = core::ptr::null_mut();
+        let align = layout.align().max(8);
+        let size = layout.size();
+        let result = unsafe { libc::posix_memalign(&mut ptr, align, size) };
+        if result != 0 {
+            return core::ptr::null_mut();
+        }
+        ptr as *mut u8
+    }
+
+    unsafe fn dealloc(&self, ptr: *mut u8, _layout: Layout) {
+        unsafe { libc::free(ptr as *mut libc::c_void) }
+    }
+
+    unsafe fn realloc(&self, ptr: *mut u8, _layout: Layout, new_size: usize) -> *mut u8 {
+        unsafe { libc::realloc(ptr as *mut libc::c_void, new_size) as *mut u8 }
+    }
+}
+
 #[cfg(windows)]
 unsafe impl GlobalAlloc for Allocator {
     unsafe fn alloc(&self, layout: Layout) -> *mut u8 {

pxl8d/src/transport.rs

@@ -116,7 +116,7 @@ impl ChunkMessage {
     }
 }
 
-#[cfg(unix)]
+#[cfg(all(unix, not(target_os = "macos")))]
 mod sys {
     use libc::{c_int, c_void, sockaddr, sockaddr_in, socklen_t};
 
@@ -131,7 +131,68 @@ mod sys {
         let addr = sockaddr_in {
             sin_family: libc::AF_INET as u16,
             sin_port: port.to_be(),
-            sin_addr: libc::in_addr { s_addr: u32::from_be_bytes([127, 0, 0, 1]).to_be() },
+            sin_addr: libc::in_addr { s_addr: 0 },
+            sin_zero: [0; 8],
+        };
+        unsafe { libc::bind(sock, &addr as *const _ as *const sockaddr, core::mem::size_of::<sockaddr_in>() as socklen_t) }
+    }
+
+    pub fn set_nonblocking(sock: RawSocket) -> c_int {
+        unsafe {
+            let flags = libc::fcntl(sock, libc::F_GETFL, 0);
+            libc::fcntl(sock, libc::F_SETFL, flags | libc::O_NONBLOCK)
+        }
+    }
+
+    pub fn recvfrom(sock: RawSocket, buf: &mut [u8], addr: &mut sockaddr_in) -> isize {
+        let mut addr_len = core::mem::size_of::<sockaddr_in>() as socklen_t;
+        unsafe {
+            libc::recvfrom(
+                sock,
+                buf.as_mut_ptr() as *mut c_void,
+                buf.len(),
+                0,
+                addr as *mut _ as *mut sockaddr,
+                &mut addr_len,
+            )
+        }
+    }
+
+    pub fn sendto(sock: RawSocket, buf: &[u8], addr: &sockaddr_in) -> isize {
+        unsafe {
+            libc::sendto(
+                sock,
+                buf.as_ptr() as *const c_void,
+                buf.len(),
+                0,
+                addr as *const _ as *const sockaddr,
+                core::mem::size_of::<sockaddr_in>() as socklen_t,
+            )
+        }
+    }
+
+    pub fn close(sock: RawSocket) {
+        unsafe { libc::close(sock) };
+    }
+}
+
+#[cfg(target_os = "macos")]
+mod sys {
+    use libc::{c_int, c_void, sockaddr, sockaddr_in, socklen_t};
+
+    pub type RawSocket = c_int;
+    pub const INVALID_SOCKET: RawSocket = -1;
+
+    pub fn socket() -> RawSocket {
+        unsafe { libc::socket(libc::AF_INET, libc::SOCK_DGRAM, 0) }
+    }
+
+    pub fn bind(sock: RawSocket, port: u16) -> c_int {
+        let addr = sockaddr_in {
+            sin_len: core::mem::size_of::<sockaddr_in>() as u8,
+            sin_family: libc::AF_INET as u8,
+            sin_port: port.to_be(),
+            sin_addr: libc::in_addr { s_addr: 0 },
             sin_zero: [0; 8],
         };
         unsafe { libc::bind(sock, &addr as *const _ as *const sockaddr, core::mem::size_of::<sockaddr_in>() as socklen_t) }

src/math/pxl8_math.h

@@ -4,17 +4,26 @@
 
 #include "pxl8_types.h"
 
-#if defined(__x86_64__) || defined(_M_X64)
+#ifndef PXL8_NO_SIMD
+    #if defined(__x86_64__) || defined(_M_X64)
         #include <xmmintrin.h>
-#elif defined(__aarch64__) || defined(_M_ARM64)
+    #elif defined(__aarch64__) || defined(_M_ARM64)
         #include <arm_neon.h>
+    #endif
 #endif
 
 #define PXL8_PI  3.14159265358979323846f
 #define PXL8_TAU (PXL8_PI * 2.0f)
 
 static inline f32 pxl8_fast_inv_sqrt(f32 x) {
-#if defined(__x86_64__) || defined(_M_X64)
+#if defined(PXL8_NO_SIMD)
+    f32 half = 0.5f * x;
+    i32 i = *(i32*)&x;
+    i = 0x5f3759df - (i >> 1);
+    x = *(f32*)&i;
+    x = x * (1.5f - half * x * x);
+    return x;
+#elif defined(__x86_64__) || defined(_M_X64)
     __m128 v = _mm_set_ss(x);
     v = _mm_rsqrt_ss(v);
     return _mm_cvtss_f32(v);
@@ -34,7 +43,9 @@ static inline f32 pxl8_fast_inv_sqrt(f32 x) {
 }
 
 static inline f32 pxl8_fast_rcp(f32 x) {
-#if defined(__x86_64__) || defined(_M_X64)
+#if defined(PXL8_NO_SIMD)
+    return 1.0f / x;
+#elif defined(__x86_64__) || defined(_M_X64)
     __m128 v = _mm_set_ss(x);
     __m128 rcp = _mm_rcp_ss(v);
     rcp = _mm_add_ss(rcp, _mm_mul_ss(rcp, _mm_sub_ss(_mm_set_ss(1.0f), _mm_mul_ss(v, rcp))));

src/net/pxl8_net.c

@@ -110,6 +110,9 @@ pxl8_result pxl8_net_connect(pxl8_net* net) {
 #endif
 
     memset(&net->server_addr, 0, sizeof(net->server_addr));
+#ifdef __APPLE__
+    net->server_addr.sin_len = sizeof(net->server_addr);
+#endif
     net->server_addr.sin_family = AF_INET;
     net->server_addr.sin_port = htons(net->port);
     inet_pton(AF_INET, net->address, &net->server_addr.sin_addr);