@bornengine/engine 0.4.16

package/native/shared/src/frame_callbacks.rs

@@ -0,0 +1,122 @@
+//! Frame callback system for Bloom Engine.
+//!
+//! Allows Perry-compiled TypeScript to register callbacks that run every frame,
+//! ordered by priority. This replaces React Three Fiber's useFrame(cb, priority).
+//!
+//! Callbacks are stored as function pointers (Perry compiles TS functions to native
+//! function pointers). Lower priority numbers run first.
+
+/// A registered frame callback.
+struct FrameCallback {
+    priority: i32,
+    callback: extern "C" fn(f64), // receives delta_time as argument
+    active: bool,
+}
+
+/// Manages frame callbacks with priority ordering.
+pub struct FrameCallbackSystem {
+    callbacks: Vec<FrameCallback>,
+    sorted: bool,
+    next_id: u64,
+    ids: Vec<u64>, // parallel to callbacks, for removal
+}
+
+impl FrameCallbackSystem {
+    pub fn new() -> Self {
+        Self {
+            callbacks: Vec::new(),
+            sorted: true,
+            next_id: 1,
+            ids: Vec::new(),
+        }
+    }
+
+    /// Register a callback with a priority. Returns an ID for removal.
+    /// Lower priority numbers run first (matching R3F convention).
+    pub fn register(&mut self, priority: i32, callback: extern "C" fn(f64)) -> u64 {
+        let id = self.next_id;
+        self.next_id += 1;
+        self.callbacks.push(FrameCallback {
+            priority,
+            callback,
+            active: true,
+        });
+        self.ids.push(id);
+        self.sorted = false;
+        id
+    }
+
+    /// Unregister a callback by ID.
+    pub fn unregister(&mut self, id: u64) {
+        if let Some(idx) = self.ids.iter().position(|&i| i == id) {
+            self.callbacks.remove(idx);
+            self.ids.remove(idx);
+        }
+    }
+
+    fn ensure_sorted(&mut self) {
+        if !self.sorted {
+            // Sort by priority (stable sort preserves insertion order for equal priorities)
+            let mut indices: Vec<usize> = (0..self.callbacks.len()).collect();
+            indices.sort_by_key(|&i| self.callbacks[i].priority);
+
+            let old_callbacks: Vec<_> = self.callbacks.drain(..).collect();
+            let old_ids: Vec<_> = self.ids.drain(..).collect();
+            for &i in &indices {
+                self.callbacks.push(FrameCallback {
+                    priority: old_callbacks[i].priority,
+                    callback: old_callbacks[i].callback,
+                    active: old_callbacks[i].active,
+                });
+                self.ids.push(old_ids[i]);
+            }
+            self.sorted = true;
+        }
+    }
+
+    /// Snapshot active callbacks in priority order so the caller can release
+    /// any engine-state lock before invoking foreign callbacks.
+    pub fn callbacks_for_frame(&mut self) -> Vec<extern "C" fn(f64)> {
+        self.ensure_sorted();
+        self.callbacks
+            .iter()
+            .filter(|cb| cb.active)
+            .map(|cb| cb.callback)
+            .collect()
+    }
+
+    /// Run all active callbacks in priority order.
+    pub fn run_all(&mut self, delta_time: f64) {
+        self.ensure_sorted();
+
+        for cb in &self.callbacks {
+            if cb.active {
+                (cb.callback)(delta_time);
+            }
+        }
+    }
+
+    /// Get number of registered callbacks.
+    pub fn count(&self) -> usize {
+        self.callbacks.len()
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::FrameCallbackSystem;
+
+    extern "C" fn callback(_: f64) {}
+
+    #[test]
+    fn callback_snapshot_is_independent_of_registry_changes() {
+        let mut callbacks = FrameCallbackSystem::new();
+        let id = callbacks.register(0, callback);
+
+        let batch = callbacks.callbacks_for_frame();
+        callbacks.unregister(id);
+
+        assert_eq!(batch.len(), 1);
+        assert_eq!(callbacks.count(), 0);
+    }
+}

package/native/shared/src/geometry.rs

@@ -0,0 +1,236 @@
+//! Geometry generation for Bloom Engine.
+//!
+//! Provides polygon extrusion (for walls and slabs) and CSG box subtraction
+//! (for door/window cutouts). These mirror the Three.js ExtrudeGeometry and
+//! three-bvh-csg functionality used by the Pascal Editor.
+
+use crate::renderer::Vertex3D;
+
+/// Result of geometry generation.
+pub struct GeometryData {
+    pub vertices: Vec<Vertex3D>,
+    pub indices: Vec<u32>,
+}
+
+/// Extrude a 2D polygon along the Y axis by the given depth.
+///
+/// - `polygon`: flat array of 2D points [x0, z0, x1, z1, ...]
+/// - `holes`: list of hole polygons, each as flat [x0, z0, x1, z1, ...]
+/// - `depth`: extrusion height (in Y direction)
+///
+/// Returns vertices and indices. The geometry extends from Y=0 to Y=depth.
+/// Normals and UVs are computed automatically.
+pub fn extrude_polygon(
+    polygon: &[f64],
+    holes: &[Vec<f64>],
+    depth: f64,
+) -> GeometryData {
+    let depth = depth as f32;
+
+    // Build earcutr input: flatten polygon + holes, track hole starts
+    let n_poly = polygon.len() / 2;
+    let mut flat_coords: Vec<f64> = polygon.to_vec();
+    let mut hole_indices: Vec<usize> = Vec::new();
+
+    for hole in holes {
+        hole_indices.push(flat_coords.len() / 2);
+        flat_coords.extend_from_slice(hole);
+    }
+
+    // Triangulate the 2D polygon
+    let triangles = earcutr::earcut(&flat_coords, &hole_indices, 2)
+        .unwrap_or_default();
+
+    let n_points = flat_coords.len() / 2;
+    let mut vertices = Vec::new();
+    let mut indices = Vec::new();
+
+    // ---- Bottom face (Y = 0, normal pointing down) ----
+    let base_bottom = 0u32;
+    for i in 0..n_points {
+        let x = flat_coords[i * 2] as f32;
+        let z = flat_coords[i * 2 + 1] as f32;
+        vertices.push(Vertex3D {
+            position: [x, 0.0, z],
+            normal: [0.0, -1.0, 0.0],
+            color: [1.0, 1.0, 1.0, 1.0],
+            uv: [x, z], // planar UV
+            joints: [0.0; 4],
+            weights: [0.0; 4],
+            tangent: [0.0; 4],
+        });
+    }
+    // Bottom triangles (reversed winding for downward-facing)
+    for tri in triangles.chunks(3) {
+        indices.push(base_bottom + tri[0] as u32);
+        indices.push(base_bottom + tri[2] as u32);
+        indices.push(base_bottom + tri[1] as u32);
+    }
+
+    // ---- Top face (Y = depth, normal pointing up) ----
+    let base_top = vertices.len() as u32;
+    for i in 0..n_points {
+        let x = flat_coords[i * 2] as f32;
+        let z = flat_coords[i * 2 + 1] as f32;
+        vertices.push(Vertex3D {
+            position: [x, depth, z],
+            normal: [0.0, 1.0, 0.0],
+            color: [1.0, 1.0, 1.0, 1.0],
+            uv: [x, z],
+            joints: [0.0; 4],
+            weights: [0.0; 4],
+            tangent: [0.0; 4],
+        });
+    }
+    for tri in triangles.chunks(3) {
+        indices.push(base_top + tri[0] as u32);
+        indices.push(base_top + tri[1] as u32);
+        indices.push(base_top + tri[2] as u32);
+    }
+
+    // ---- Side faces (walls of the extrusion) ----
+    // Process each edge of the outer polygon and each hole
+    let mut edge_loops: Vec<Vec<usize>> = Vec::new();
+
+    // Outer polygon edges
+    let outer_loop: Vec<usize> = (0..n_poly).collect();
+    edge_loops.push(outer_loop);
+
+    // Hole edges
+    for (hi, hole) in holes.iter().enumerate() {
+        let n_hole = hole.len() / 2;
+        let start = hole_indices[hi];
+        let hole_loop: Vec<usize> = (start..start + n_hole).collect();
+        edge_loops.push(hole_loop);
+    }
+
+    for edge_loop in &edge_loops {
+        let n = edge_loop.len();
+        for i in 0..n {
+            let i0 = edge_loop[i];
+            let i1 = edge_loop[(i + 1) % n];
+
+            let x0 = flat_coords[i0 * 2] as f32;
+            let z0 = flat_coords[i0 * 2 + 1] as f32;
+            let x1 = flat_coords[i1 * 2] as f32;
+            let z1 = flat_coords[i1 * 2 + 1] as f32;
+
+            // Edge direction and outward normal
+            let dx = x1 - x0;
+            let dz = z1 - z0;
+            let len = (dx * dx + dz * dz).sqrt();
+            if len < 1e-6 { continue; }
+            let nx = -dz / len;
+            let nz = dx / len;
+
+            // 4 vertices for this side quad
+            let base = vertices.len() as u32;
+
+            // Bottom-left, bottom-right, top-right, top-left
+            let u_len = len;
+            vertices.push(Vertex3D {
+                position: [x0, 0.0, z0],
+                normal: [nx, 0.0, nz],
+                color: [1.0, 1.0, 1.0, 1.0],
+                uv: [0.0, 0.0],
+                joints: [0.0; 4],
+                weights: [0.0; 4],
+                tangent: [0.0; 4],
+            });
+            vertices.push(Vertex3D {
+                position: [x1, 0.0, z1],
+                normal: [nx, 0.0, nz],
+                color: [1.0, 1.0, 1.0, 1.0],
+                uv: [u_len, 0.0],
+                joints: [0.0; 4],
+                weights: [0.0; 4],
+                tangent: [0.0; 4],
+            });
+            vertices.push(Vertex3D {
+                position: [x1, depth, z1],
+                normal: [nx, 0.0, nz],
+                color: [1.0, 1.0, 1.0, 1.0],
+                uv: [u_len, depth],
+                joints: [0.0; 4],
+                weights: [0.0; 4],
+                tangent: [0.0; 4],
+            });
+            vertices.push(Vertex3D {
+                position: [x0, depth, z0],
+                normal: [nx, 0.0, nz],
+                color: [1.0, 1.0, 1.0, 1.0],
+                uv: [0.0, depth],
+                joints: [0.0; 4],
+                weights: [0.0; 4],
+                tangent: [0.0; 4],
+            });
+
+            indices.push(base);
+            indices.push(base + 1);
+            indices.push(base + 2);
+            indices.push(base);
+            indices.push(base + 2);
+            indices.push(base + 3);
+        }
+    }
+
+    GeometryData { vertices, indices }
+}
+
+/// Subtract an axis-aligned box from existing geometry.
+///
+/// This is a simplified CSG operation that clips triangles against a box.
+/// For Phase 2 MVP, we use a simple approach: remove triangles fully inside
+/// the box and clip intersecting ones. This handles the common case of
+/// door/window cutouts in walls.
+///
+/// - `min`: box minimum corner [x, y, z]
+/// - `max`: box maximum corner [x, y, z]
+pub fn subtract_box(
+    geo: &GeometryData,
+    min: [f32; 3],
+    max: [f32; 3],
+) -> GeometryData {
+    let mut out_vertices = Vec::new();
+    let mut out_indices = Vec::new();
+
+    // Process each triangle
+    for tri in geo.indices.chunks(3) {
+        if tri.len() < 3 { continue; }
+        let v0 = &geo.vertices[tri[0] as usize];
+        let v1 = &geo.vertices[tri[1] as usize];
+        let v2 = &geo.vertices[tri[2] as usize];
+
+        // Check if any vertex is inside the box
+        let in0 = point_in_box(&v0.position, &min, &max);
+        let in1 = point_in_box(&v1.position, &min, &max);
+        let in2 = point_in_box(&v2.position, &min, &max);
+
+        if in0 && in1 && in2 {
+            // Triangle fully inside box — discard
+            continue;
+        }
+
+        // Triangle fully outside or partially intersecting — keep for now
+        // (Full CSG clipping would split partial triangles, but for MVP
+        //  removing fully-interior triangles handles most cutout cases)
+        let base = out_vertices.len() as u32;
+        out_vertices.push(*v0);
+        out_vertices.push(*v1);
+        out_vertices.push(*v2);
+        out_indices.push(base);
+        out_indices.push(base + 1);
+        out_indices.push(base + 2);
+    }
+
+    GeometryData {
+        vertices: out_vertices,
+        indices: out_indices,
+    }
+}
+
+fn point_in_box(p: &[f32; 3], min: &[f32; 3], max: &[f32; 3]) -> bool {
+    p[0] >= min[0] && p[0] <= max[0]
+    && p[1] >= min[1] && p[1] <= max[1]
+    && p[2] >= min[2] && p[2] <= max[2]
+}

package/native/shared/src/handles.rs

@@ -0,0 +1,182 @@
+//! Generic handle registry: maps f64 handles to owned values.
+//!
+//! Handles are **generational**: the f64 encodes a 1-based slot index in
+//! the low 32 bits and a generation counter above it. Freeing a slot
+//! bumps its generation, so a stale handle held by game code after a
+//! free/realloc cycle fails the lookup instead of silently aliasing
+//! whatever object reused the slot — the classic use-after-free-by-index
+//! bug this registry used to permit.
+//!
+//! Encoding: `value = (generation << 32) | (slot + 1)`, stored in an f64.
+//! f64 represents integers exactly up to 2^53, generations wrap at 2^21
+//! (a slot must be freed two million times, and the stale handle
+//! retained throughout, to produce a false positive). Generation 0
+//! handles are plain small integers — the representation games saw
+//! before generations existed.
+//!
+//! `0` is never a valid handle.
+
+const SLOT_MASK: u64 = 0xFFFF_FFFF;
+const GEN_SHIFT: u32 = 32;
+/// Generations wrap below 2^21 so the full encoded value stays under
+/// 2^53 (exact f64 integer range).
+const GEN_WRAP: u64 = 1 << 21;
+
+pub struct HandleRegistry<T> {
+    items: Vec<Option<T>>,
+    generations: Vec<u64>,
+    free_list: Vec<usize>,
+}
+
+impl<T> Default for HandleRegistry<T> {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl<T> HandleRegistry<T> {
+    pub fn new() -> Self {
+        Self {
+            items: Vec::new(),
+            generations: Vec::new(),
+            free_list: Vec::new(),
+        }
+    }
+
+    fn encode(&self, idx: usize) -> f64 {
+        ((self.generations[idx] << GEN_SHIFT) | (idx as u64 + 1)) as f64
+    }
+
+    /// Decode a handle to a live slot index, or None if the handle is
+    /// invalid, out of range, freed, or from a previous generation.
+    fn decode(&self, handle: f64) -> Option<usize> {
+        if !(handle.is_finite() && handle > 0.0) {
+            return None;
+        }
+        let v = handle as u64;
+        let slot = v & SLOT_MASK;
+        let gen = v >> GEN_SHIFT;
+        if slot == 0 || slot as usize > self.items.len() {
+            return None;
+        }
+        let idx = slot as usize - 1;
+        if self.generations[idx] != gen {
+            return None; // stale handle from before a free()
+        }
+        self.items[idx].as_ref()?;
+        Some(idx)
+    }
+
+    /// Allocate a handle for the given item.
+    pub fn alloc(&mut self, item: T) -> f64 {
+        if let Some(idx) = self.free_list.pop() {
+            self.items[idx] = Some(item);
+            self.encode(idx)
+        } else {
+            self.items.push(Some(item));
+            self.generations.push(0);
+            self.encode(self.items.len() - 1)
+        }
+    }
+
+    /// Get a reference to the item at the given handle.
+    pub fn get(&self, handle: f64) -> Option<&T> {
+        self.decode(handle).and_then(|idx| self.items[idx].as_ref())
+    }
+
+    /// Get a mutable reference to the item at the given handle.
+    pub fn get_mut(&mut self, handle: f64) -> Option<&mut T> {
+        let idx = self.decode(handle)?;
+        self.items[idx].as_mut()
+    }
+
+    /// Free the item at the given handle. The slot's generation is bumped
+    /// so every outstanding copy of this handle becomes invalid.
+    pub fn free(&mut self, handle: f64) -> Option<T> {
+        let idx = self.decode(handle)?;
+        let item = self.items[idx].take();
+        if item.is_some() {
+            self.generations[idx] = (self.generations[idx] + 1) % GEN_WRAP;
+            self.free_list.push(idx);
+        }
+        item
+    }
+
+    /// Number of slots (including freed). Use for iteration bounds.
+    pub fn capacity(&self) -> usize {
+        self.items.len()
+    }
+
+    /// Iterate over all live (handle, &T) pairs. Handles carry their
+    /// current generation — they compare equal to what alloc() returned.
+    pub fn iter(&self) -> impl Iterator<Item = (f64, &T)> {
+        self.items.iter().enumerate().filter_map(|(idx, slot)| {
+            slot.as_ref()
+                .map(|item| (((self.generations[idx] << GEN_SHIFT) | (idx as u64 + 1)) as f64, item))
+        })
+    }
+
+    /// Iterate over all live (handle, &mut T) pairs.
+    pub fn iter_mut(&mut self) -> impl Iterator<Item = (f64, &mut T)> {
+        let generations = &self.generations;
+        self.items.iter_mut().enumerate().filter_map(move |(idx, slot)| {
+            slot.as_mut()
+                .map(|item| (((generations[idx] << GEN_SHIFT) | (idx as u64 + 1)) as f64, item))
+        })
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn alloc_get_free() {
+        let mut r = HandleRegistry::new();
+        let h = r.alloc("a");
+        assert_eq!(r.get(h), Some(&"a"));
+        assert_eq!(r.free(h), Some("a"));
+        assert_eq!(r.get(h), None);
+    }
+
+    #[test]
+    fn first_generation_handles_are_small_integers() {
+        let mut r = HandleRegistry::new();
+        assert_eq!(r.alloc("a"), 1.0);
+        assert_eq!(r.alloc("b"), 2.0);
+    }
+
+    #[test]
+    fn stale_handle_does_not_alias_reused_slot() {
+        let mut r = HandleRegistry::new();
+        let old = r.alloc("old");
+        r.free(old);
+        let new = r.alloc("new"); // reuses slot 0 with generation 1
+        assert_ne!(old.to_bits(), new.to_bits());
+        assert_eq!(r.get(old), None, "stale handle resolved after slot reuse");
+        assert_eq!(r.get(new), Some(&"new"));
+        // double-free through the stale handle is a no-op
+        assert_eq!(r.free(old), None);
+        assert_eq!(r.get(new), Some(&"new"));
+    }
+
+    #[test]
+    fn iter_returns_current_generation_handles() {
+        let mut r = HandleRegistry::new();
+        let a = r.alloc(1);
+        r.free(a);
+        let b = r.alloc(2);
+        let collected: Vec<(f64, &i32)> = r.iter().collect();
+        assert_eq!(collected.len(), 1);
+        assert_eq!(collected[0].0.to_bits(), b.to_bits());
+        assert_eq!(r.get(collected[0].0), Some(&2));
+    }
+
+    #[test]
+    fn garbage_handles_rejected() {
+        let r: HandleRegistry<i32> = HandleRegistry::new();
+        for h in [0.0, -1.0, 0.5, f64::NAN, f64::INFINITY, 1e300] {
+            assert!(r.get(h).is_none());
+        }
+    }
+}