@bloomengine/engine 0.3.1 → 0.3.2

package/native/windows/src/lib.rs

@@ -1,6 +1,6 @@
 use bloom_shared::engine::EngineState;
 use bloom_shared::renderer::Renderer;
-use bloom_shared::string_header::str_from_header;
+use bloom_shared::string_header::{alloc_perry_string, str_from_header};
 use bloom_shared::audio::{parse_wav, parse_ogg, parse_mp3};
 
 use std::sync::OnceLock;
@@ -344,6 +344,11 @@ pub extern "C" fn bloom_init_window(width: f64, height: f64, title_ptr: *const u
             wgpu::ExperimentalFeatures::disabled()
         };
         let mut required_limits = wgpu::Limits::default();
+        // Phase 1c: the material ABI declares 5 bind groups (PerFrame,
+        // PerView, PerMaterial, PerDraw, SceneInputs). wgpu's default
+        // limit is 4. Metal / Vulkan / D3D12 support at least 7, so 5 is
+        // safely within every real backend's capabilities.
+        required_limits.max_bind_groups = 5;
         if required_features.intersects(rt_mask) {
             required_limits = required_limits
                 .using_minimum_supported_acceleration_structure_values();
@@ -1587,24 +1592,14 @@ pub extern "C" fn bloom_file_exists(path_ptr: *const u8) -> f64 {
 #[no_mangle]
 pub extern "C" fn bloom_read_file(path_ptr: *const u8) -> *const u8 {
     let path = str_from_header(path_ptr);
+    // Always return a valid Perry string. A null pointer would NaN-box into a
+    // string-typed JS value pointing at address 0; subsequent `.length` /
+    // `.charCodeAt` reads dereference the bogus StringHeader and segfault.
+    // Callers detect "missing file" via `data.length === 0` (e.g. the
+    // jump game's discoverLevels probe across level1..level10 / custom_*).
     match std::fs::read_to_string(path) {
-        Ok(contents) => {
-            // Return Perry-format string: StringHeader (length u32 + capacity u32 + refcount u32) followed by UTF-8 data
-            let bytes = contents.as_bytes();
-            let len = bytes.len();
-            let total = 12 + len; // 12 bytes header (3 × u32) + data
-            let layout = std::alloc::Layout::from_size_align(total, 4).unwrap();
-            unsafe {
-                let ptr = std::alloc::alloc(layout);
-                if ptr.is_null() { return std::ptr::null(); }
-                *(ptr as *mut u32) = len as u32;           // length
-                *(ptr.add(4) as *mut u32) = len as u32;    // capacity
-                *(ptr.add(8) as *mut u32) = 1;             // refcount (unique)
-                std::ptr::copy_nonoverlapping(bytes.as_ptr(), ptr.add(12), len);
-                ptr
-            }
-        }
-        Err(_) => std::ptr::null(),
+        Ok(contents) => alloc_perry_string(&contents),
+        Err(_)       => alloc_perry_string(""),
     }
 }
 
@@ -1897,6 +1892,219 @@ pub extern "C" fn bloom_set_sss_enabled(on: f64) {
     engine().renderer.set_sss_enabled(on != 0.0);
 }
 
+// ============================================================
+// Render scale / upscale / DRS / post-FX / screenshots / impulse
+// Ports of the macOS / Linux FFI surface so the bloom/core TS layer
+// links cleanly on Windows. EngineState in bloom-shared already
+// exposes the underlying renderer methods, so these wrappers are
+// platform-agnostic.
+// ============================================================
+
+#[no_mangle]
+pub extern "C" fn bloom_take_screenshot(path_ptr: *const u8) {
+    let path = str_from_header(path_ptr).to_string();
+    let eng = engine();
+    eng.renderer.screenshot_requested = true;
+    eng.renderer.pending_screenshot_path = Some(path);
+}
+
+#[no_mangle]
+pub extern "C" fn bloom_set_env_clear_from_hdr(path_ptr: *const u8) {
+    use image::ImageDecoder;
+    let path = str_from_header(path_ptr).to_string();
+    let file = match std::fs::File::open(&path) {
+        Ok(f) => f,
+        Err(_) => return,
+    };
+    let decoder = match image::codecs::hdr::HdrDecoder::new(std::io::BufReader::new(file)) {
+        Ok(d) => d,
+        Err(_) => return,
+    };
+    let (w, h) = decoder.dimensions();
+    let byte_len = (w as usize) * (h as usize) * 3 * 4;
+    let mut buf = vec![0u8; byte_len];
+    if decoder.read_image(&mut buf).is_err() {
+        return;
+    }
+    let rgb_f32: Vec<f32> = buf
+        .chunks_exact(4)
+        .map(|c| f32::from_le_bytes([c[0], c[1], c[2], c[3]]))
+        .collect();
+    engine().renderer.load_env_from_hdr(w, h, &rgb_f32);
+}
+
+#[no_mangle]
+pub extern "C" fn bloom_set_fog(r: f64, g: f64, b: f64, density: f64, height_ref: f64, height_falloff: f64) {
+    let r_ = engine();
+    r_.renderer.set_fog_color(r as f32, g as f32, b as f32);
+    r_.renderer.set_fog_density(density as f32);
+    r_.renderer.set_fog_height_falloff(height_ref as f32, height_falloff as f32);
+}
+
+#[no_mangle]
+pub extern "C" fn bloom_set_chromatic_aberration(strength: f64) {
+    engine().renderer.set_chromatic_aberration(strength as f32);
+}
+
+#[no_mangle]
+pub extern "C" fn bloom_set_vignette(strength: f64, softness: f64) {
+    engine().renderer.set_vignette(strength as f32, softness as f32);
+}
+
+#[no_mangle]
+pub extern "C" fn bloom_set_film_grain(strength: f64) {
+    engine().renderer.set_film_grain(strength as f32);
+}
+
+#[no_mangle]
+pub extern "C" fn bloom_set_sun_shafts(strength: f64, decay: f64, r: f64, g: f64, b: f64) {
+    let eng = engine();
+    eng.renderer.set_sun_shaft_strength(strength as f32);
+    eng.renderer.set_sun_shaft_decay(decay as f32);
+    eng.renderer.set_sun_shaft_color(r as f32, g as f32, b as f32);
+}
+
+#[no_mangle]
+pub extern "C" fn bloom_set_auto_exposure(on: f64) {
+    engine().renderer.set_auto_exposure(on != 0.0);
+}
+
+#[no_mangle]
+pub extern "C" fn bloom_set_taa_enabled(on: f64) {
+    engine().renderer.set_taa_enabled(on != 0.0);
+}
+
+#[no_mangle]
+pub extern "C" fn bloom_set_render_scale(scale: f64) {
+    engine().renderer.set_render_scale(scale as f32);
+}
+
+#[no_mangle]
+pub extern "C" fn bloom_get_render_scale() -> f64 {
+    engine().renderer.render_scale() as f64
+}
+
+#[no_mangle]
+pub extern "C" fn bloom_set_upscale_mode(mode: f64) {
+    engine().renderer.set_upscale_mode(mode as u32);
+}
+
+#[no_mangle]
+pub extern "C" fn bloom_set_cas_strength(strength: f64) {
+    engine().renderer.set_cas_strength(strength as f32);
+}
+
+#[no_mangle]
+pub extern "C" fn bloom_get_physical_width() -> f64 {
+    engine().renderer.physical_width() as f64
+}
+
+#[no_mangle]
+pub extern "C" fn bloom_get_physical_height() -> f64 {
+    engine().renderer.physical_height() as f64
+}
+
+#[no_mangle]
+pub extern "C" fn bloom_set_auto_resolution(target_hz: f64, enabled: f64) {
+    let eng = engine();
+    if enabled != 0.0 {
+        let current = eng.renderer.render_scale();
+        eng.drs.enable(target_hz as f32, current);
+    } else {
+        eng.drs.disable();
+    }
+}
+
+#[no_mangle]
+pub extern "C" fn bloom_set_manual_exposure(value: f64) {
+    engine().renderer.set_manual_exposure(value as f32);
+}
+
+#[no_mangle]
+pub extern "C" fn bloom_set_env_intensity(intensity: f64) {
+    engine().renderer.set_env_intensity(intensity as f32);
+}
+
+#[no_mangle]
+pub extern "C" fn bloom_set_ssgi_enabled(enabled: f64) {
+    engine().renderer.set_ssgi_enabled(enabled != 0.0);
+}
+
+#[no_mangle]
+pub extern "C" fn bloom_set_ssgi_intensity(intensity: f64) {
+    engine().renderer.set_ssgi_intensity(intensity as f32);
+}
+
+#[no_mangle]
+pub extern "C" fn bloom_set_ssgi_radius(radius: f64) {
+    engine().renderer.set_ssgi_radius(radius as f32);
+}
+
+#[no_mangle]
+pub extern "C" fn bloom_set_dof(enabled: f64, focus_distance: f64, aperture: f64) {
+    let r = &mut engine().renderer;
+    r.set_dof_enabled(enabled != 0.0);
+    r.set_dof_focus_distance(focus_distance as f32);
+    r.set_dof_aperture(aperture as f32);
+}
+
+#[no_mangle]
+pub extern "C" fn bloom_splat_impulse(x: f64, z: f64, radius: f64, strength: f64) {
+    engine().renderer.impulse_field.submit_splat(
+        x as f32, z as f32, radius as f32, strength as f32,
+    );
+}
+
+// Render texture FFI (stub — GPU implementation deferred).
+#[no_mangle]
+pub extern "C" fn bloom_load_render_texture(width: f64, height: f64) -> f64 {
+    engine().textures.load_render_texture(width as u32, height as u32)
+}
+#[no_mangle]
+pub extern "C" fn bloom_unload_render_texture(handle: f64) {
+    engine().textures.unload_render_texture(handle);
+}
+#[no_mangle]
+pub extern "C" fn bloom_begin_texture_mode(_handle: f64) {
+    // Stub: no-op until GPU render-to-texture is wired.
+}
+#[no_mangle]
+pub extern "C" fn bloom_end_texture_mode() {
+    // Stub: no-op.
+}
+#[no_mangle]
+pub extern "C" fn bloom_get_render_texture_texture(handle: f64) -> f64 {
+    engine().textures.get_render_texture_texture(handle)
+}
+
+#[no_mangle]
+pub extern "C" fn bloom_profiler_frame_history() -> *const u8 {
+    let hist = engine().profiler.frame_history();
+    let mut s = String::with_capacity(hist.len() * 24);
+    for (cpu, gpu) in &hist {
+        s.push_str(&format!("{:.2}|{:.2}\n", cpu, gpu));
+    }
+    alloc_perry_string(&s)
+}
+
+#[no_mangle]
+pub extern "C" fn bloom_profiler_overlay_text() -> *const u8 {
+    let snap = engine().profiler.snapshot();
+    let mut s = String::with_capacity(snap.len() * 48);
+    for (label, cpu, gpu) in &snap {
+        s.push_str(label);
+        s.push('|');
+        s.push_str(&format!("{:.2}", cpu));
+        s.push('|');
+        match gpu {
+            Some(g) => s.push_str(&format!("{:.2}", g)),
+            None    => s.push_str("-1"),
+        }
+        s.push('\n');
+    }
+    alloc_perry_string(&s)
+}
+
 // ============================================================
 // Profiler — CPU phase timings (always available) + GPU timestamps
 // (when the adapter supports TIMESTAMP_QUERY). Disabled by default.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bloomengine/engine",
-  "version": "0.3.1",
+  "version": "0.3.2",
   "description": "Bloom Engine: native TypeScript game engine compiled by Perry",
   "main": "src/index.ts",
   "types": "src/index.ts",
@@ -203,7 +203,7 @@
         { "name": "bloom_clear_all_post_passes",       "params": [],                                                   "returns": "void" },
         { "name": "bloom_draw_material",            "params": ["f64", "f64", "f64", "f64", "f64", "f64", "f64", "f64", "f64", "f64", "f64"], "returns": "void" },
         { "name": "bloom_load_model_animation",   "params": ["i64"],                                                   "returns": "f64"  },
-        { "name": "bloom_update_model_animation",  "params": ["f64", "f64", "f64", "f64", "f64", "f64", "f64"],       "returns": "void" },
+        { "name": "bloom_update_model_animation",  "params": ["f64", "f64", "f64", "f64", "f64", "f64", "f64", "f64"], "returns": "void" },
         { "name": "bloom_create_mesh",             "params": ["i64", "f64", "i64", "f64"],                             "returns": "f64"  },
         { "name": "bloom_set_joint_test",          "params": ["f64", "f64"],                                            "returns": "void" },
         { "name": "bloom_set_ambient_light",       "params": ["f64", "f64", "f64", "f64"],                              "returns": "void" },
@@ -287,7 +287,7 @@
         { "name": "bloom_get_model_bounds_max_z",   "params": ["f64"],                                                   "returns": "f64"  },
         { "name": "bloom_write_file",               "params": ["i64", "i64"],                                            "returns": "f64"  },
         { "name": "bloom_file_exists",              "params": ["i64"],                                                   "returns": "f64"  },
-        { "name": "bloom_read_file",                "params": ["i64"],                                                   "returns": "i64"  },
+        { "name": "bloom_read_file",                "params": ["i64"],                                                   "returns": "string"  },
         { "name": "bloom_get_touch_x",              "params": ["f64"],                                                   "returns": "f64"  },
         { "name": "bloom_get_touch_y",              "params": ["f64"],                                                   "returns": "f64"  },
         { "name": "bloom_get_touch_count",          "params": [],                                                        "returns": "f64"  },
@@ -315,9 +315,9 @@
         { "name": "bloom_scene_node_index_count",   "params": ["f64"],                                                   "returns": "f64"  },
         { "name": "bloom_set_cursor_shape",            "params": ["f64"],                                                   "returns": "void" },
         { "name": "bloom_set_clipboard_text",          "params": ["i64"],                                                   "returns": "void" },
-        { "name": "bloom_get_clipboard_text",          "params": [],                                                        "returns": "i64"  },
-        { "name": "bloom_open_file_dialog",            "params": ["i64", "i64"],                                            "returns": "i64"  },
-        { "name": "bloom_save_file_dialog",            "params": ["i64", "i64"],                                            "returns": "i64"  },
+        { "name": "bloom_get_clipboard_text",          "params": [],                                                        "returns": "string"  },
+        { "name": "bloom_open_file_dialog",            "params": ["i64", "i64"],                                            "returns": "string"  },
+        { "name": "bloom_save_file_dialog",            "params": ["i64", "i64"],                                            "returns": "string"  },
         { "name": "bloom_scene_pick_all",              "params": ["f64", "f64", "f64"],                                     "returns": "f64"  },
         { "name": "bloom_pick_all_handle",             "params": ["f64"],                                                   "returns": "f64"  },
         { "name": "bloom_pick_all_distance",           "params": ["f64"],                                                   "returns": "f64"  },
@@ -538,7 +538,8 @@
         },
         "linux": {
           "crate": "native/linux/",
-          "lib": "libbloom_linux.a",
+          "lib": "libbloom_linux_bundled.a",
+          "libs": ["stdc++"],
           "pkgConfig": ["x11", "xi", "alsa"]
         },
         "android": {

package/src/core/colors.ts

@@ -1,6 +1,10 @@
-import { Color } from './types';
+import { Color as ColorType } from './types';
 
-export const ColorConstants: Record<string, Color> = {
+// Canonical color palette. Re-exported as `Color` from `bloom/core` and
+// declared as a real top-level binding (not an alias re-export) so Perry
+// emits a `_perry_fn_src_core_colors_ts__Color` symbol that examples
+// importing `Color` from `bloom/core` can link against.
+export const Color: Record<string, ColorType> = {
   RayWhite:   { r: 245, g: 245, b: 245, a: 255 },
   White:      { r: 255, g: 255, b: 255, a: 255 },
   Black:      { r: 0,   g: 0,   b: 0,   a: 255 },
@@ -27,30 +31,33 @@ export const ColorConstants: Record<string, Color> = {
   Blank:      { r: 0,   g: 0,   b: 0,   a: 0   },
 };
 
+// Backward-compatible alias — same object, kept for older imports.
+export const ColorConstants = Color;
+
 // Backward-compatible alias with SCREAMING_SNAKE keys
-export const Colors: Record<string, Color> = {
-  WHITE:      ColorConstants.White,
-  BLACK:      ColorConstants.Black,
-  RED:        ColorConstants.Red,
-  GREEN:      ColorConstants.Green,
-  BLUE:       ColorConstants.Blue,
-  YELLOW:     ColorConstants.Yellow,
-  ORANGE:     ColorConstants.Orange,
-  PINK:       ColorConstants.Pink,
-  PURPLE:     ColorConstants.Purple,
-  DARKGRAY:   ColorConstants.DarkGray,
-  LIGHTGRAY:  ColorConstants.LightGray,
-  GRAY:       ColorConstants.Gray,
-  DARKBLUE:   ColorConstants.DarkBlue,
-  SKYBLUE:    ColorConstants.SkyBlue,
-  LIME:       ColorConstants.Lime,
-  DARKGREEN:  ColorConstants.DarkGreen,
-  GOLD:       ColorConstants.Gold,
-  MAROON:     ColorConstants.Maroon,
-  BROWN:      ColorConstants.Brown,
-  BEIGE:      ColorConstants.Beige,
-  MAGENTA:    ColorConstants.Magenta,
-  VIOLET:     ColorConstants.Violet,
-  RAYWHITE:   ColorConstants.RayWhite,
-  BLANK:      ColorConstants.Blank,
+export const Colors: Record<string, ColorType> = {
+  WHITE:      Color.White,
+  BLACK:      Color.Black,
+  RED:        Color.Red,
+  GREEN:      Color.Green,
+  BLUE:       Color.Blue,
+  YELLOW:     Color.Yellow,
+  ORANGE:     Color.Orange,
+  PINK:       Color.Pink,
+  PURPLE:     Color.Purple,
+  DARKGRAY:   Color.DarkGray,
+  LIGHTGRAY:  Color.LightGray,
+  GRAY:       Color.Gray,
+  DARKBLUE:   Color.DarkBlue,
+  SKYBLUE:    Color.SkyBlue,
+  LIME:       Color.Lime,
+  DARKGREEN:  Color.DarkGreen,
+  GOLD:       Color.Gold,
+  MAROON:     Color.Maroon,
+  BROWN:      Color.Brown,
+  BEIGE:      Color.Beige,
+  MAGENTA:    Color.Magenta,
+  VIOLET:     Color.Violet,
+  RAYWHITE:   Color.RayWhite,
+  BLANK:      Color.Blank,
 };

package/src/core/index.ts

@@ -1,8 +1,7 @@
 import { Color, Camera2D, Camera3D } from './types';
 
 export type { Color, Vec2, Vec3, Vec4, Rect, Camera2D, Camera3D, Texture, Font, Sound, Music, Quat, Ray, BoundingBox, Model, Mat4, RayHit, FrustumPlanes } from './types';
-export { ColorConstants, Colors } from './colors';
-export { ColorConstants as Color } from './colors';
+export { Color, ColorConstants, Colors } from './colors';
 export { Key, MouseButton } from './keys';
 
 // FFI declarations