@bornengine/engine 0.4.16

package/native/web/src/ragdoll_ffi.rs

@@ -0,0 +1,250 @@
+//! EN-063 — ragdolls on web.
+//!
+//! The native ragdoll FFI (`bloom-shared/src/ffi_core/ragdoll_ffi.rs`) is a
+//! thin choreography layer: `ragdoll::plan()` decides the capsules, Jolt
+//! creates them, `Ragdoll::attach/apply` map simulated bodies back onto the
+//! skinning palette. All of that planning/pose math is pure Rust and compiles
+//! on wasm32 — the only thing missing on web was the Jolt half, which lives
+//! in JS (`jolt_bridge.js`). So this module is the same choreography with
+//! `eng.jolt.*` swapped for the bridge externs, plus one new bridge function
+//! (`constraintSixDofLockedTranslation`) for the joint type ragdolls use.
+//!
+//! Tuning constants (12 bodies, 0.38 radius fraction, the rot limits, the
+//! friction/damping set) are copied from the native FFI verbatim — a corpse
+//! must read the same on every platform.
+
+use crate::engine;
+use crate::physics_ffi::{
+    jb_body_add_impulse, jb_body_create, jb_body_destroy, jb_body_get_position,
+    jb_body_get_rotation, jb_body_set_angular_damping, jb_body_set_friction,
+    jb_body_set_linear_damping, jb_body_set_restitution, jb_constraint_destroy,
+    jb_constraint_six_dof, jb_shape_capsule,
+};
+use wasm_bindgen::prelude::*;
+
+#[wasm_bindgen]
+pub fn bloom_ragdoll_create() -> f64 {
+    engine().ragdolls.create() as f64
+}
+
+#[wasm_bindgen]
+pub fn bloom_ragdoll_activate(
+    rag: f64,
+    anim: f64,
+    world: f64,
+    scale: f64,
+    px: f64,
+    py: f64,
+    pz: f64,
+    rot_y: f64,
+) -> f64 {
+    let eng = engine();
+
+    let builds = {
+        let Some(a) = eng.models.get_animation(anim) else {
+            return 0.0;
+        };
+        // 12 bodies / 0.38 radius fraction — same sweet spot as native (spine
+        // + limbs; past that you buy fingers, which cost solver time and buy
+        // jitter).
+        bloom_shared::ragdoll::plan(
+            a,
+            scale as f32,
+            [px as f32, py as f32, pz as f32],
+            rot_y as f32,
+            12,
+            0.38,
+        )
+    };
+    if builds.is_empty() {
+        return 0.0;
+    }
+
+    // --- bodies (layer 1 = MOVING, motion type 2 = DYNAMIC)
+    let mut bodies: Vec<f64> = Vec::with_capacity(builds.len());
+    for b in builds.iter() {
+        let shape = jb_shape_capsule(b.half_height as f64, b.radius as f64);
+        if shape == 0.0 {
+            bodies.push(0.0);
+            continue;
+        }
+        let q = bloom_shared::ragdoll::quat_from_mat(&b.world);
+        let body = jb_body_create(
+            world,
+            shape,
+            2.0,
+            b.world[3][0] as f64,
+            b.world[3][1] as f64,
+            b.world[3][2] as f64,
+            q[0] as f64,
+            q[1] as f64,
+            q[2] as f64,
+            q[3] as f64,
+            1.0,
+        );
+        if body != 0.0 {
+            jb_body_set_friction(body, 0.8); // corpses do not skate
+            jb_body_set_restitution(body, 0.02); // they do not bounce
+            jb_body_set_linear_damping(body, 0.20);
+            // Angular damping does most of the work of making this read as a
+            // body rather than a rag.
+            jb_body_set_angular_damping(body, 0.75);
+        }
+        bodies.push(body);
+    }
+
+    // --- joints. Tight-ish; twist (y) held hardest — an over-twisted limb is
+    // the single most obviously WRONG thing a ragdoll can do.
+    let rot_limits: [f64; 6] = [-0.8, 0.8, -0.25, 0.25, -0.8, 0.8];
+    let mut constraints: Vec<f64> = Vec::new();
+    for (i, b) in builds.iter().enumerate() {
+        if b.parent_bone == usize::MAX {
+            continue;
+        }
+        let pa = bodies.get(b.parent_bone).copied().unwrap_or(0.0);
+        let pb = bodies.get(i).copied().unwrap_or(0.0);
+        if pa == 0.0 || pb == 0.0 {
+            continue;
+        }
+        let c = jb_constraint_six_dof(
+            pa,
+            pb,
+            b.anchor[0] as f64,
+            b.anchor[1] as f64,
+            b.anchor[2] as f64,
+            b.anchor[0] as f64,
+            b.anchor[1] as f64,
+            b.anchor[2] as f64,
+            rot_limits[0],
+            rot_limits[1],
+            rot_limits[2],
+            rot_limits[3],
+            rot_limits[4],
+            rot_limits[5],
+            1.0, // anchors given in world space
+        );
+        if c != 0.0 {
+            constraints.push(c);
+        }
+    }
+
+    let Some(a) = eng.models.get_animation(anim) else {
+        return 0.0;
+    };
+    let Some(r) = eng.ragdolls.get_mut(rag as u32) else {
+        return 0.0;
+    };
+    r.attach(
+        &builds,
+        &bodies,
+        constraints,
+        a,
+        scale as f32,
+        [px as f32, py as f32, pz as f32],
+        rot_y as f32,
+    );
+    1.0
+}
+
+#[wasm_bindgen]
+pub fn bloom_ragdoll_push(rag: f64, dx: f64, dy: f64, dz: f64, impulse: f64) {
+    let eng = engine();
+    let Some(r) = eng.ragdolls.get(rag as u32) else {
+        return;
+    };
+    if !r.active {
+        return;
+    }
+    let bodies = r.bodies();
+    if bodies.is_empty() {
+        return;
+    }
+    // Spread the impulse over the bodies so a 12-bone corpse and a 4-bone one
+    // take off at the same speed.
+    let per = impulse / (bodies.len() as f64);
+    for b in bodies {
+        jb_body_add_impulse(b, dx * per, dy * per, dz * per);
+    }
+}
+
+#[wasm_bindgen]
+pub fn bloom_ragdoll_update(rag: f64, anim: f64, dt: f64) -> f64 {
+    let eng = engine();
+
+    let (bodies, scale, pos, rot) = {
+        let Some(r) = eng.ragdolls.get(rag as u32) else {
+            return 0.0;
+        };
+        if !r.active {
+            return 0.0;
+        }
+        let (s, p, ry) = r.upload_params();
+        (r.bodies(), s, p, ry)
+    };
+
+    let mut world: Vec<[[f32; 4]; 4]> = Vec::with_capacity(bodies.len());
+    for b in bodies.iter() {
+        let p = [
+            jb_body_get_position(*b, 0.0) as f32,
+            jb_body_get_position(*b, 1.0) as f32,
+            jb_body_get_position(*b, 2.0) as f32,
+        ];
+        let q = [
+            jb_body_get_rotation(*b, 0.0) as f32,
+            jb_body_get_rotation(*b, 1.0) as f32,
+            jb_body_get_rotation(*b, 2.0) as f32,
+            jb_body_get_rotation(*b, 3.0) as f32,
+        ];
+        world.push(bloom_shared::ragdoll::from_pos_quat(p, q));
+    }
+
+    {
+        let Some(r) = eng.ragdolls.get_mut(rag as u32) else {
+            return 0.0;
+        };
+        r.age += dt as f32;
+    }
+    let age = eng.ragdolls.get(rag as u32).map(|r| r.age).unwrap_or(0.0);
+
+    // Split borrow: apply() needs &mut ModelAnimation and &Ragdoll.
+    let ragdoll_ptr: *const bloom_shared::ragdoll::Ragdoll =
+        match eng.ragdolls.get(rag as u32) {
+            Some(r) => r,
+            None => return 0.0,
+        };
+    if let Some(a) = eng.models.get_animation_mut(anim) {
+        unsafe { (*ragdoll_ptr).apply(a, &world) };
+    }
+
+    if let Some(a) = eng.models.get_animation(anim) {
+        if !a.joint_matrices.is_empty() {
+            let (s, c) = (rot.sin(), rot.cos());
+            // PT-7: anim handle = prev-palette pairing key.
+            eng.renderer
+                .set_joint_matrices_scaled(anim.to_bits(), &a.joint_matrices, scale, pos, s, c);
+        }
+    }
+    age as f64
+}
+
+#[wasm_bindgen]
+pub fn bloom_ragdoll_release(rag: f64) {
+    let eng = engine();
+    let (bodies, cons) = {
+        let Some(r) = eng.ragdolls.get(rag as u32) else {
+            return;
+        };
+        (r.bodies(), r.constraint_handles().to_vec())
+    };
+    // Constraints first: destroying a body out from under a live constraint
+    // is how you get a use-after-free in the solver.
+    for c in cons {
+        jb_constraint_destroy(c);
+    }
+    for b in bodies {
+        jb_body_destroy(b);
+    }
+    if let Some(r) = eng.ragdolls.get_mut(rag as u32) {
+        *r = bloom_shared::ragdoll::Ragdoll::new();
+    }
+}

package/native/web/src/render_settings.rs

@@ -0,0 +1,98 @@
+//! Renderer-settings FFI surface for web — wasm_bindgen wrappers over
+//! the same shared engine methods native's define_core_ffi! generates
+//! wrappers for. Split from lib.rs (2000-line file policy).
+
+use crate::engine;
+use wasm_bindgen::prelude::*;
+
+// ---------------------------------------------------------------------------
+// Renderer settings — parity with the native define_core_ffi! surface.
+// (Added when tools/validate-ffi.js gained web coverage; these were the
+// silent gaps that made web games' graphics settings no-ops.)
+// ---------------------------------------------------------------------------
+
+#[wasm_bindgen]
+pub 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);
+}
+#[wasm_bindgen]
+pub fn bloom_set_chromatic_aberration(strength: f64) { engine().renderer.set_chromatic_aberration(strength as f32); }
+#[wasm_bindgen]
+pub fn bloom_set_vignette(strength: f64, softness: f64) { engine().renderer.set_vignette(strength as f32, softness as f32); }
+#[wasm_bindgen]
+pub fn bloom_set_film_grain(strength: f64) { engine().renderer.set_film_grain(strength as f32); }
+#[wasm_bindgen]
+pub 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);
+}
+#[wasm_bindgen]
+pub fn bloom_set_auto_exposure(on: f64) { engine().renderer.set_auto_exposure(on != 0.0); }
+#[wasm_bindgen]
+pub fn bloom_set_manual_exposure(value: f64) { engine().renderer.set_manual_exposure(value as f32); }
+#[wasm_bindgen]
+pub fn bloom_set_taa_enabled(on: f64) { engine().renderer.set_taa_enabled(on != 0.0); }
+#[wasm_bindgen]
+pub fn bloom_set_occlusion_culling(on: f64) { engine().renderer.occlusion.enabled = on != 0.0; }
+#[wasm_bindgen]
+pub fn bloom_set_render_scale(scale: f64) { engine().renderer.set_render_scale(scale as f32); }
+#[wasm_bindgen]
+pub fn bloom_get_render_scale() -> f64 { engine().renderer.render_scale() as f64 }
+#[wasm_bindgen]
+pub fn bloom_set_upscale_mode(mode: f64) { engine().renderer.set_upscale_mode(mode as u32); }
+#[wasm_bindgen]
+pub fn bloom_set_cas_strength(strength: f64) { engine().renderer.set_cas_strength(strength as f32); }
+#[wasm_bindgen]
+pub fn bloom_get_physical_width() -> f64 { engine().renderer.physical_width() as f64 }
+#[wasm_bindgen]
+pub fn bloom_get_physical_height() -> f64 { engine().renderer.physical_height() as f64 }
+#[wasm_bindgen]
+pub 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();
+    }
+}
+#[wasm_bindgen]
+pub fn bloom_set_env_intensity(intensity: f64) { engine().renderer.set_env_intensity(intensity as f32); }
+#[wasm_bindgen]
+pub fn bloom_set_ssgi_enabled(enabled: f64) { engine().renderer.set_ssgi_enabled(enabled != 0.0); }
+#[wasm_bindgen]
+pub fn bloom_set_ssgi_intensity(intensity: f64) { engine().renderer.set_ssgi_intensity(intensity as f32); }
+#[wasm_bindgen]
+pub fn bloom_set_ssgi_radius(radius: f64) { engine().renderer.set_ssgi_radius(radius as f32); }
+#[wasm_bindgen]
+pub 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);
+}
+
+// LOD: pointer-taking variants share the cross-module WASM memory TODO
+// with bloom_scene_update_geometry above; the model-based variant works.
+#[wasm_bindgen]
+pub fn bloom_scene_set_lod(
+    _handle: f64, _lod_index: f64, _vert_ptr: f64, _vert_count: f64,
+    _idx_ptr: f64, _idx_count: f64, _max_coverage: f64,
+) {
+    // TODO: Phase 4 — pointer/buffer passing from Perry WASM linear memory.
+}
+#[wasm_bindgen]
+pub fn bloom_scene_attach_model_lod(node: f64, model: f64, mesh_index: f64, lod_index: f64, max_coverage: f64) {
+    let eng = engine();
+    let mi = mesh_index as usize;
+    let Some(md) = eng.models.models.get(model) else { return };
+    if mi >= md.meshes.len() { return; }
+    let mesh = &md.meshes[mi];
+    let (v, i) = (mesh.vertices.clone(), mesh.indices.clone());
+    eng.scene.set_lod_geometry(node, lod_index as usize, v, i, max_coverage as f32);
+}