@bloomengine/engine 0.4.2 → 0.4.4

package/README.md

@@ -5,6 +5,10 @@
 Write TypeScript. Ship native games — and now the web too.
 Bloom compiles your game to Metal, DirectX 12, Vulkan, OpenGL, and WebGPU — one codebase for every platform.
 
+> **Inspired by [raylib](https://github.com/raysan5/raylib).** Bloom models its public
+> API on raylib's — in our view one of the best API designs in gamedev. Bloom is an
+> independent implementation, not a port — [how Bloom relates to raylib »](#how-bloom-relates-to-raylib)
+
 ## Install
 
 ```bash
@@ -37,7 +41,7 @@ initWindow(800, 450, "My Game");
 
 while (!windowShouldClose()) {
   beginDrawing();
-  clearBackground(Colors.RAYWHITE);
+  clearBackground(Colors.SNOW);
   drawText("Hello, Bloom!", 190, 200, 20, Colors.DARKGRAY);
   endDrawing();
 }
@@ -53,7 +57,7 @@ import { initWindow, runGame, clearBackground, drawText, Colors } from "@bloomen
 initWindow(800, 450, "My Game");
 
 runGame((dt) => {
-  clearBackground(Colors.RAYWHITE);
+  clearBackground(Colors.SNOW);
   drawText("Hello, Bloom!", 190, 200, 20, Colors.DARKGRAY);
 });
 ```
@@ -73,6 +77,23 @@ cd dist/web && python3 -m http.server 8080
 - **Unified 2D/3D** — Shapes, textures, text, 3D models, and audio in one engine.
 - **Zero magic** — Explicit game loops, no hidden framework overhead.
 
+## How Bloom relates to raylib
+
+Bloom's public API is heavily inspired by [raylib](https://github.com/raysan5/raylib).
+raylib's API is, in our opinion, one of the best in the gamedev space — a flat library
+of plain functions, no classes, small enough to learn from a cheatsheet — so we model
+ours on it. You'll recognize the shape immediately: `initWindow`, `beginDrawing`,
+`clearBackground`, `drawText`, and modules named core / shapes / textures / text /
+audio / models.
+
+That's where the relationship ends. **Bloom's implementation is entirely independent —
+it does not link against, embed, or call raylib.** Bloom compiles TypeScript directly to
+native code via Perry, our LLVM-based AOT compiler, and renders through wgpu (Metal,
+DirectX 12, Vulkan, OpenGL, WebGPU). It is not a port or a binding — just an engine that
+admires raylib's API design. Thanks to
+[Ramon Santamaria (@raysan5)](https://github.com/raysan5) and the raylib community for
+setting the bar. ([full design rationale](docs/design-api.md))
+
 ## Modules
 
 | Module | Import | Description |

package/native/ios/Cargo.toml

@@ -11,6 +11,14 @@ crate-type = ["staticlib"]
 default = ["jolt"]
 jolt = ["bloom-shared/jolt"]
 
+# Match perry-runtime's panic strategy so the final perry-driven link
+# doesn't see two copies of rust_eh_personality (and friends) from two
+# independent Rust staticlibs. ld64.lld flags these as duplicate symbols;
+# GNU ld silently tolerates them, which is why only Apple targets break.
+# Mirrors the same setting in native/watchos/Cargo.toml.
+[profile.release]
+panic = "abort"
+
 [dependencies]
 bloom-shared = { path = "../shared", default-features = false, features = ["mp3"] }
 objc2 = "0.6"

package/native/macos/Cargo.toml

@@ -15,6 +15,14 @@ crate-type = ["staticlib"]
 default = ["jolt"]
 jolt = ["bloom-shared/jolt"]
 
+# Match perry-runtime's panic strategy so the final perry-driven link
+# doesn't see two copies of rust_eh_personality (and friends) from two
+# independent Rust staticlibs. ld64.lld flags these as duplicate symbols;
+# GNU ld silently tolerates them, which is why only Apple targets break.
+# Mirrors the same setting in native/watchos/Cargo.toml.
+[profile.release]
+panic = "abort"
+
 [dependencies]
 bloom-shared = { path = "../shared", default-features = false, features = ["mp3"] }
 image = { version = "0.25", default-features = false, features = ["hdr"] }

package/native/tvos/Cargo.lock

@@ -110,6 +110,7 @@ name = "bloom-tvos"
 version = "0.1.0"
 dependencies = [
  "bloom-shared",
+ "image",
  "objc2",
  "objc2-foundation",
  "raw-window-handle",

package/native/tvos/Cargo.toml

@@ -11,12 +11,22 @@ crate-type = ["staticlib"]
 default = ["jolt"]
 jolt = ["bloom-shared/jolt"]
 
+# Match perry-runtime's panic strategy so the final perry-driven link
+# doesn't see two copies of rust_eh_personality (and friends) from two
+# independent Rust staticlibs. ld64.lld flags these as duplicate symbols;
+# GNU ld silently tolerates them, which is why only Apple targets break.
+# Mirrors the same setting in native/watchos/Cargo.toml.
+[profile.release]
+panic = "abort"
+
 [dependencies]
 bloom-shared = { path = "../shared", default-features = false, features = ["mp3"] }
 objc2 = "0.6"
 objc2-foundation = { version = "0.3", features = ["NSDate", "NSRunLoop", "NSString", "NSThread", "NSObject"] }
 raw-window-handle = "0.6"
 wgpu = "29"
+# Needed by bloom_set_env_clear_from_hdr (HDR env-map decode); mirrors macOS.
+image = { version = "0.25", default-features = false, features = ["hdr"] }
 
 [patch.crates-io]
 metal = { path = "metal-patched" }

package/native/tvos/src/lib.rs

@@ -3177,3 +3177,154 @@ fn bloom_jolt_ffi_physics() -> &'static mut bloom_shared::physics_jolt::JoltPhys
 
 #[cfg(feature = "jolt")]
 bloom_shared::define_physics_ffi!();
+
+// ============================================================
+// Screenshot + HDR env + Post-FX / resolution FFI
+// ------------------------------------------------------------
+// Ported from native/macos/src/lib.rs. These delegate to the shared
+// bloom_shared renderer (identical type used here), so they are real
+// implementations, not stubs. They were present on macOS/linux/windows
+// but missing on tvOS, which caused `ld64.lld: undefined symbol: _bloom_*`
+// link errors for any app using the post-processing API on tvOS.
+// ============================================================
+
+/// Request a PNG screenshot of the next rendered frame. The capture happens
+/// during the next end_drawing(); used by bloom-diff / CI image regression.
+#[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);
+}
+
+/// Load an HDR equirectangular environment map and upload it to the GPU.
+/// The file must be Radiance HDR (.hdr).
+#[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);
+}
+
+// --- Post-FX knobs (heuristic visual layer; default-off) ---
+
+#[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);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bloomengine/engine",
-  "version": "0.4.2",
+  "version": "0.4.4",
   "description": "Bloom Engine: native TypeScript game engine compiled by Perry",
   "main": "src/index.ts",
   "types": "src/index.ts",
@@ -536,7 +536,7 @@
         },
         "linux": {
           "crate": "native/linux/",
-          "lib": "libbloom_linux_bundled.a",
+          "lib": "libbloom_linux.a",
           "libs": ["stdc++"],
           "pkgConfig": ["x11", "xi", "alsa"]
         },

package/src/core/colors.ts

@@ -5,7 +5,7 @@ import { Color as ColorType } from './types';
 // 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 },
+  Snow:       { 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 },
   Red:        { r: 230, g: 41,  b: 55,  a: 255 },
@@ -58,6 +58,6 @@ export const Colors: Record<string, ColorType> = {
   BEIGE:      Color.Beige,
   MAGENTA:    Color.Magenta,
   VIOLET:     Color.Violet,
-  RAYWHITE:   Color.RayWhite,
+  SNOW:       Color.Snow,
   BLANK:      Color.Blank,
 };