@bloomengine/engine 0.3.1

package/native/shared/src/engine.rs

@@ -0,0 +1,186 @@
+use crate::audio::AudioMixer;
+use crate::input::InputState;
+use crate::renderer::Renderer;
+use crate::text_renderer::TextRenderer;
+use crate::textures::TextureManager;
+use crate::models::ModelManager;
+use crate::scene::SceneGraph;
+use crate::frame_callbacks::FrameCallbackSystem;
+use crate::postfx::PostFxPipeline;
+use crate::profiler::Profiler;
+use crate::drs::DrsController;
+#[cfg(all(feature = "jolt", not(target_arch = "wasm32")))]
+use crate::physics_jolt::JoltPhysics;
+
+#[cfg(feature = "web")]
+use web_time::Instant;
+#[cfg(not(feature = "web"))]
+use std::time::Instant;
+
+pub struct EngineState {
+    pub renderer: Renderer,
+    pub text: TextRenderer,
+    pub input: InputState,
+    pub audio: AudioMixer,
+    pub textures: TextureManager,
+    pub models: ModelManager,
+    pub scene: SceneGraph,
+    pub frame_callbacks: FrameCallbackSystem,
+    pub postfx: Option<PostFxPipeline>,
+    pub profiler: Profiler,
+    pub screenshot_pending: bool,
+    pub drs: DrsController,
+
+    // Timing
+    pub target_fps: f64,
+    pub delta_time: f64,
+    last_frame_time: Instant,
+    frame_count: u64,
+    fps_timer: Instant,
+    fps_frame_count: u64,
+    current_fps: f64,
+    start_time: Instant,
+
+    pub should_close: bool,
+
+    // When true, end_frame() takes a direct-to-swapchain path that skips
+    // scene graph prep, shadow maps, HDR/post-FX, SDF/WSRC bakes, etc.
+    // Intended for pure-2D games that only need the batched 2D pipeline.
+    // Off by default to preserve existing behaviour.
+    pub direct_2d_mode: bool,
+
+    #[cfg(all(feature = "jolt", not(target_arch = "wasm32")))]
+    pub jolt: JoltPhysics,
+}
+
+impl EngineState {
+    pub fn new(renderer: Renderer) -> Self {
+        let now = Instant::now();
+        let mut profiler = Profiler::new();
+        profiler.init_gpu(&renderer.device, &renderer.queue);
+        // Ticket 007b: tell the scene graph whether the device was
+        // created with HW ray-query so geometry upload pays the BLAS /
+        // BLAS_INPUT cost only when it can be used.
+        let mut scene = SceneGraph::new();
+        scene.hw_rt_enabled = renderer.hw_rt_enabled;
+        Self {
+            renderer,
+            text: TextRenderer::new(),
+            input: InputState::new(),
+            audio: AudioMixer::new(),
+            textures: TextureManager::new(),
+            models: ModelManager::new(),
+            scene,
+            frame_callbacks: FrameCallbackSystem::new(),
+            postfx: None,
+            profiler,
+            screenshot_pending: false,
+            drs: DrsController::new(),
+            target_fps: 60.0,
+            delta_time: 0.0,
+            last_frame_time: now,
+            frame_count: 0,
+            fps_timer: now,
+            fps_frame_count: 0,
+            current_fps: 0.0,
+            start_time: now,
+            should_close: false,
+            direct_2d_mode: false,
+            #[cfg(all(feature = "jolt", not(target_arch = "wasm32")))]
+            jolt: JoltPhysics::new(),
+        }
+    }
+
+    pub fn begin_frame(&mut self) {
+        let now = Instant::now();
+        self.delta_time = now.duration_since(self.last_frame_time).as_secs_f64();
+        self.last_frame_time = now;
+
+        // DRS samples wall-clock frame time and may step render_scale
+        // up or down before this frame's renderer work begins. No-op
+        // when disabled (default) — and the controller's own cooldown
+        // + hysteresis bound how often a step actually happens.
+        self.drs.tick(self.delta_time, &mut self.renderer);
+
+        self.fps_frame_count += 1;
+        let fps_elapsed = now.duration_since(self.fps_timer).as_secs_f64();
+        if fps_elapsed >= 1.0 {
+            self.current_fps = self.fps_frame_count as f64 / fps_elapsed;
+            self.fps_frame_count = 0;
+            self.fps_timer = now;
+        }
+
+        self.input.begin_frame();
+        self.renderer.begin_frame();
+        self.frame_count += 1;
+
+        // Run frame callbacks after begin_frame (matching R3F's useFrame timing)
+        self.profiler.begin("frame_callbacks");
+        self.frame_callbacks.run_all(self.delta_time);
+        self.profiler.end("frame_callbacks");
+    }
+
+    pub fn end_frame(&mut self) {
+        if self.direct_2d_mode {
+            // Fast path for pure-2D games: render direct to the swapchain,
+            // skipping scene prep, shadow maps, HDR/tonemap, SSAO, bloom,
+            // SDF/WSRC bakes and mesh-card capture. On mobile GPUs the
+            // full deferred pipeline easily costs tens of ms/frame even
+            // when the scene graph is empty; this path typically hits
+            // 60 fps on the same device.
+            self.profiler.begin("render_total");
+            self.renderer.end_frame();
+            self.profiler.end("render_total");
+        } else {
+            self.profiler.begin("scene_prepare");
+            self.scene.prepare(
+                &self.renderer.device,
+                &self.renderer.queue,
+                &self.renderer.vp_matrix(),
+                &self.renderer.prev_vp_matrix,
+                self.renderer.uniform_3d_layout(),
+            );
+            self.scene.prepare_materials(&self.renderer);
+            self.profiler.end("scene_prepare");
+
+            // Phase 6 — drain hot-reload events and rebuild any
+            // material whose .wgsl file changed on disk. Cheap when
+            // nothing has changed (just a try_recv on an empty queue).
+            self.renderer.poll_material_hot_reload();
+
+            // Sync material-system PerFrame + PerView UBOs with the
+            // current clock + camera before dispatching any queued
+            // material draws. Without this, group 1 (view/proj/camera/
+            // lights/shadow) is zero and shaders that read e.g.
+            // `view.view_proj` produce offscreen geometry.
+            let t  = self.get_time() as f32;
+            let dt = self.delta_time as f32;
+            self.renderer.material_system_begin_frame(t, dt);
+
+            self.profiler.begin("render_total");
+            self.renderer.end_frame_with_scene(&mut self.scene, &mut self.profiler);
+            self.profiler.end("render_total");
+        }
+
+        self.profiler.frame_end(&self.renderer.device);
+        self.input.end_frame();
+
+        // Vsync (PresentMode::Fifo, the wgpu default) already caps frame rate.
+        // Only apply CPU sleep-based cap when vsync is not active.
+        // On WASM, frame pacing is handled by requestAnimationFrame.
+        #[cfg(not(target_arch = "wasm32"))]
+        if self.target_fps > 0.0 && !self.renderer.vsync_active() {
+            let target_frame_time = 1.0 / self.target_fps;
+            let elapsed = self.last_frame_time.elapsed().as_secs_f64();
+            if elapsed < target_frame_time {
+                let sleep_time = target_frame_time - elapsed;
+                std::thread::sleep(std::time::Duration::from_secs_f64(sleep_time));
+            }
+        }
+    }
+
+    pub fn get_fps(&self) -> f64 { self.current_fps }
+    pub fn get_time(&self) -> f64 { self.start_time.elapsed().as_secs_f64() }
+    pub fn screen_width(&self) -> f64 { self.renderer.width() as f64 }
+    pub fn screen_height(&self) -> f64 { self.renderer.height() as f64 }
+}

package/native/shared/src/frame_callbacks.rs

@@ -0,0 +1,88 @@
+//! 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);
+        }
+    }
+
+    /// Run all active callbacks in priority order.
+    pub fn run_all(&mut self, delta_time: f64) {
+        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;
+        }
+
+        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()
+    }
+}

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,76 @@
+/// Generic handle registry: maps f64 handles to owned values.
+/// Handles are small integer indices (1-based) cast to f64 for FFI.
+pub struct HandleRegistry<T> {
+    items: Vec<Option<T>>,
+    free_list: Vec<usize>,
+}
+
+impl<T> HandleRegistry<T> {
+    pub fn new() -> Self {
+        Self {
+            items: Vec::new(),
+            free_list: Vec::new(),
+        }
+    }
+
+    /// Allocate a handle for the given item. Returns a 1-based index as f64.
+    pub fn alloc(&mut self, item: T) -> f64 {
+        if let Some(idx) = self.free_list.pop() {
+            self.items[idx] = Some(item);
+            (idx + 1) as f64
+        } else {
+            self.items.push(Some(item));
+            self.items.len() as f64
+        }
+    }
+
+    /// Get a reference to the item at the given handle.
+    pub fn get(&self, handle: f64) -> Option<&T> {
+        let idx = handle as usize;
+        if idx == 0 || idx > self.items.len() {
+            return None;
+        }
+        self.items[idx - 1].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 = handle as usize;
+        if idx == 0 || idx > self.items.len() {
+            return None;
+        }
+        self.items[idx - 1].as_mut()
+    }
+
+    /// Free the item at the given handle.
+    pub fn free(&mut self, handle: f64) -> Option<T> {
+        let idx = handle as usize;
+        if idx == 0 || idx > self.items.len() {
+            return None;
+        }
+        let item = self.items[idx - 1].take();
+        if item.is_some() {
+            self.free_list.push(idx - 1);
+        }
+        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.
+    pub fn iter(&self) -> impl Iterator<Item = (f64, &T)> {
+        self.items.iter().enumerate().filter_map(|(idx, slot)| {
+            slot.as_ref().map(|item| ((idx + 1) as f64, item))
+        })
+    }
+
+    /// Iterate over all live (handle, &mut T) pairs.
+    pub fn iter_mut(&mut self) -> impl Iterator<Item = (f64, &mut T)> {
+        self.items.iter_mut().enumerate().filter_map(|(idx, slot)| {
+            slot.as_mut().map(|item| ((idx + 1) as f64, item))
+        })
+    }
+}