@bornengine/engine 0.4.16 → 0.5.1

package/native/web/bloom_glue.js

@@ -52,6 +52,8 @@ let manifestPaths = null;   // Set<string> when a manifest was loaded
 // browser only grants pointer lock inside a user gesture, and revokes it on
 // ESC without delivering the keydown. Both mismatches are reconciled here.
 let wantPointerLock = false;
+let uiTextInput = null;
+let uiTextInputFocused = false;
 
 /**
  * Idempotent engine bootstrap. Safe to call multiple times; only the first
@@ -204,6 +206,14 @@ function buildFfiImports() {
   imports.bloom_measure_text_ex = (font, text, size, spacing) =>
     bloom.bloom_measure_text_ex_str(font, String(text), size, spacing);
 
+  // Route whole-string UI commands through wasm-bindgen string parameters.
+  imports.bloom_ui_command = (backend, opcode, id, a, b, c, d, text) =>
+    bloom.bloom_ui_command_str(backend, opcode, id, a, b, c, d, String(text));
+  imports.bloom_ui_scratch_command = (backend, opcode, id, count, text) =>
+    bloom.bloom_ui_scratch_command_str(backend, opcode, id, count, String(text));
+  imports.bloom_ui_inject_text = (text) =>
+    bloom.bloom_ui_inject_text_str(String(text));
+
   // --- Materials & post-FX: shader source strings route to _str variants ---
   const materialVariants = [
     'bloom_compile_material', 'bloom_compile_material_refractive',
@@ -384,6 +394,7 @@ function startRafLoop() {
       document.getElementById('loading')?.remove();
     }
     flushInput();
+    syncUiKeyboardRequest();
     bloom.bloom_begin_drawing();
     if (gameCallback !== null && typeof globalThis.callWasmClosure === 'function') {
       const dt = bloom.bloom_get_delta_time();
@@ -520,6 +531,44 @@ function setupDomBridge() {
   const canvas = document.getElementById('bloom-canvas');
   if (!canvas) return;
 
+  // Browsers deliver text and IME composition through DOM editing events,
+  // not keyboard key codes. Keep a real focusable control so mobile browsers
+  // can show their soft keyboard, while visually leaving the game canvas
+  // unchanged.
+  uiTextInput = document.createElement('textarea');
+  uiTextInput.setAttribute('aria-label', 'Game text input');
+  uiTextInput.autocomplete = 'off';
+  uiTextInput.autocapitalize = 'off';
+  uiTextInput.spellcheck = false;
+  Object.assign(uiTextInput.style, {
+    position: 'fixed', left: '0', bottom: '0', width: '1px', height: '1px',
+    padding: '0', border: '0', opacity: '0', resize: 'none', overflow: 'hidden',
+    zIndex: '-1', caretColor: 'transparent',
+  });
+  document.body.appendChild(uiTextInput);
+  let composing = false;
+  uiTextInput.addEventListener('compositionstart', () => { composing = true; });
+  uiTextInput.addEventListener('compositionend', (e) => {
+    composing = false;
+    if (e.data) bloom.bloom_ui_inject_text(String(e.data));
+    uiTextInput.value = '';
+  });
+  uiTextInput.addEventListener('input', (e) => {
+    if (composing || e.isComposing || e.inputType === 'insertFromComposition') {
+      uiTextInput.value = '';
+      return;
+    }
+    if (e.inputType?.startsWith('insert') && e.data) {
+      bloom.bloom_ui_inject_text(String(e.data));
+    }
+    uiTextInput.value = '';
+  });
+  uiTextInput.addEventListener('paste', (e) => {
+    const text = e.clipboardData?.getData('text/plain') ?? '';
+    if (text) bloom.bloom_ui_inject_text(text);
+    e.preventDefault();
+  });
+
   // HiDPI: keep the canvas backing store + renderer surface in sync with the
   // CSS box and devicePixelRatio. Clamp dpr to 3 to bound GPU cost.
   function syncCanvasSize() {
@@ -570,10 +619,10 @@ function setupDomBridge() {
     const code = keyMap[e.code];
     if (code !== undefined) {
       inputQueue.push({ kind: 'key', k: 'k' + code, code, up: false });
-      if (e.code !== 'F12' && e.code !== 'F5') e.preventDefault();
+      if (!uiTextInputFocused && e.code !== 'F12' && e.code !== 'F5') e.preventDefault();
     }
     if (typeof bloom.bloom_inject_char === 'function'
-        && e.key.length === 1 && !e.ctrlKey && !e.metaKey && !e.altKey) {
+        && !uiTextInputFocused && e.key.length === 1 && !e.ctrlKey && !e.metaKey && !e.altKey) {
       bloom.bloom_inject_char(e.key.codePointAt(0));
     }
   });
@@ -634,14 +683,21 @@ function setupDomBridge() {
   // Touch. Browser touch identifiers are arbitrary; map them onto stable
   // slots 0..N-1 the way the engine's sparse touch API expects. Release goes
   // through the deferred path so a same-frame tap stays visible.
-  const touchSlots = new Map(); // identifier → slot
-  function slotFor(id) {
-    let s = touchSlots.get(id);
-    if (s !== undefined) return s;
+  const touchSlots = new Map(); // browser identifier → stable engine slot
+  const touchCapacity = Math.max(0, Math.min(10,
+    (typeof bloom.bloom_get_max_touch_points === 'function'
+      ? bloom.bloom_get_max_touch_points() : 10) | 0));
+  function slotForStart(id) {
+    const existing = touchSlots.get(id);
+    if (existing !== undefined) return existing;
     const used = new Set(touchSlots.values());
-    for (s = 0; used.has(s); s++);
-    touchSlots.set(id, s);
-    return s;
+    for (let slot = 0; slot < touchCapacity; slot++) {
+      if (!used.has(slot)) {
+        touchSlots.set(id, slot);
+        return slot;
+      }
+    }
+    return undefined;
   }
   function touchXY(t) {
     const rect = canvas.getBoundingClientRect();
@@ -650,15 +706,19 @@ function setupDomBridge() {
   canvas.addEventListener('touchstart', (e) => {
     resumeAudio();
     for (const t of e.changedTouches) {
+      const slot = slotForStart(t.identifier);
+      if (slot === undefined) continue;
       const [x, y] = touchXY(t);
-      bloom.bloom_inject_touch(slotFor(t.identifier), x, y, 1);
+      bloom.bloom_inject_touch(slot, x, y, 1);
     }
     e.preventDefault();
   }, { passive: false });
   canvas.addEventListener('touchmove', (e) => {
     for (const t of e.changedTouches) {
+      const slot = touchSlots.get(t.identifier);
+      if (slot === undefined) continue;
       const [x, y] = touchXY(t);
-      bloom.bloom_inject_touch(slotFor(t.identifier), x, y, 1);
+      bloom.bloom_inject_touch(slot, x, y, 1);
     }
     e.preventDefault();
   }, { passive: false });
@@ -678,6 +738,19 @@ function setupDomBridge() {
   document.addEventListener('pointerdown', resumeAudio);
 }
 
+function syncUiKeyboardRequest() {
+  if (!uiTextInput || typeof bloom.bloom_ui_take_keyboard_request !== 'function') return;
+  const request = bloom.bloom_ui_take_keyboard_request(0);
+  if (request > 0.5 && !uiTextInputFocused) {
+    uiTextInputFocused = true;
+    uiTextInput.focus({ preventScroll: true });
+  } else if (request >= 0 && request <= 0.5 && uiTextInputFocused) {
+    uiTextInputFocused = false;
+    uiTextInput.blur();
+    uiTextInput.value = '';
+  }
+}
+
 // --- Auto-boot on import ---
 // The page creates `window.__bloomReady` (a pending promise) in a classic
 // inline <script> during parse; the gated `bootPerryWasm(...)` call awaits it.

package/native/web/build.sh

@@ -2,7 +2,7 @@
 # Build Bloom Engine for Web
 #
 # Usage:
-#   ./native/web/build.sh [game.ts] [--output dist/]
+#   ./native/web/build.sh [--dev | --release] [game.ts] [--output dist/]
 #
 # Steps:
 #   1. Build bloom_web.wasm via wasm-pack
@@ -12,54 +12,167 @@
 # Prerequisites:
 #   - wasm-pack: cargo install wasm-pack
 #   - perry: ../../../perry/perry/target/release/perry (or in PATH)
-#   - wasm-opt (optional): for binary size optimization
 
-set -e
+set -euo pipefail
 
-SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
-ENGINE_DIR="$(cd "$SCRIPT_DIR/../.." && pwd)"
+SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd -P)"
+ENGINE_DIR="$(cd "$SCRIPT_DIR/../.." && pwd -P)"
 WEB_CRATE="$SCRIPT_DIR"
-OUTPUT_DIR="${2:-$ENGINE_DIR/dist/web}"
-GAME_FILE="$1"
+BUILD_PROFILE="--release"
+PROFILE_SET=0
+OUTPUT_DIR=""
+GAME_FILE=""
+GAME_FILE_INPUT=""
+GAME_DIR=""
+
+usage() {
+  cat <<'USAGE'
+Usage: ./native/web/build.sh [--dev | --release] [game.ts] [--output dist/]
+
+Profiles:
+  --dev       Faster iterative build; skips wasm-opt.
+  --release   Optimized build (default); runs wasm-opt once with -Oz.
+
+Options:
+  --output DIR  Write the assembled site to DIR (default: dist/web).
+  -h, --help    Show this help.
+USAGE
+}
+
+usage_error() {
+  echo "ERROR: $1" >&2
+  usage >&2
+  exit 2
+}
+
+while (($#)); do
+  case "$1" in
+    --dev|--release)
+      if ((PROFILE_SET)) && [[ "$BUILD_PROFILE" != "$1" ]]; then
+        usage_error "--dev and --release cannot be used together"
+      fi
+      BUILD_PROFILE="$1"
+      PROFILE_SET=1
+      shift
+      ;;
+    --output)
+      (($# >= 2)) || usage_error "--output requires a directory"
+      [[ -n "$2" ]] || usage_error "--output requires a directory"
+      OUTPUT_DIR="$2"
+      shift 2
+      ;;
+    --output=*)
+      OUTPUT_DIR="${1#*=}"
+      [[ -n "$OUTPUT_DIR" ]] || usage_error "--output requires a directory"
+      shift
+      ;;
+    -h|--help)
+      usage
+      exit 0
+      ;;
+    -* )
+      usage_error "unknown option: $1"
+      ;;
+    *)
+      [[ -z "$GAME_FILE" ]] || usage_error "only one game file may be provided"
+      GAME_FILE="$1"
+      shift
+      ;;
+  esac
+done
+
+OUTPUT_DIR="${OUTPUT_DIR:-$ENGINE_DIR/dist/web}"
+if [[ "$OUTPUT_DIR" != /* ]]; then
+  OUTPUT_DIR="$PWD/$OUTPUT_DIR"
+fi
+OUTPUT_DIR="$(python3 -c 'import os, sys; print(os.path.realpath(sys.argv[1]))' "$OUTPUT_DIR")"
 
-# Resolve the game file to an absolute path NOW, while still in the caller's
-# working directory — the build cd's into the web crate before compiling, so a
-# relative path like `examples/pong/main.ts` would otherwise no longer resolve.
+# Resolve game paths before validating output: cleanup must never remove game
+# source files or the assets directory that will be copied into the build.
 if [ -n "$GAME_FILE" ]; then
   if [ -f "$GAME_FILE" ]; then
-    GAME_FILE="$(cd "$(dirname "$GAME_FILE")" && pwd)/$(basename "$GAME_FILE")"
+    GAME_FILE_INPUT="$(python3 -c 'import os, sys; path = sys.argv[1]; print(os.path.join(os.path.realpath(os.path.dirname(path) or "."), os.path.basename(path)))' "$GAME_FILE")"
+    GAME_FILE="$(python3 -c 'import os, sys; print(os.path.realpath(sys.argv[1]))' "$GAME_FILE_INPUT")"
+    GAME_DIR="$(dirname "$GAME_FILE")"
   else
     echo "ERROR: game file not found: $GAME_FILE"
     exit 1
   fi
 fi
 
+if [[ "$OUTPUT_DIR" == "/" || "$OUTPUT_DIR" == "$WEB_CRATE" || "$OUTPUT_DIR" == "$WEB_CRATE/"* || "$WEB_CRATE" == "$OUTPUT_DIR/"* ]]; then
+  usage_error "--output must not overlap the native/web source tree"
+fi
+
+# Resolve game-output cleanup paths against the source file and its assets
+# directory. This permits common output folders such as <game>/dist/web while
+# rejecting destinations whose owned artifacts would erase game inputs.
+if [ -n "$GAME_FILE" ]; then
+  if ! python3 - "$OUTPUT_DIR" "$GAME_FILE_INPUT" "$GAME_FILE" "$GAME_DIR" <<'PY'
+import os
+import sys
+
+output_dir, game_file_input, game_file_target, game_dir = sys.argv[1:]
+output_dir = os.path.realpath(output_dir)
+game_file_input = os.path.abspath(game_file_input)
+game_file_target = os.path.realpath(game_file_target)
+game_assets_target = os.path.join(os.path.realpath(game_dir), "assets")
+game_assets_input = os.path.join(os.path.dirname(game_file_input), "assets")
+cleaned_paths = [
+    os.path.join(output_dir, "pkg"),
+    os.path.join(output_dir, "assets"),
+    os.path.join(output_dir, "index.html"),
+    os.path.join(output_dir, "bloom_glue.js"),
+    os.path.join(output_dir, "jolt_bridge.js"),
+]
+source_paths = [game_file_input, game_file_target]
+for game_assets in (game_assets_input, game_assets_target):
+    if os.path.lexists(game_assets):
+        source_paths.extend((os.path.abspath(game_assets), os.path.realpath(game_assets)))
+
+cleanup_aliases = []
+for cleaned in cleaned_paths:
+    cleaned = os.path.abspath(cleaned)
+    cleanup_aliases.extend((cleaned, os.path.realpath(cleaned)))
+
+def overlaps(left, right):
+    try:
+        common = os.path.commonpath((left, right))
+        if common == left or common == right:
+            return True
+        return os.path.lexists(left) and os.path.lexists(right) and os.path.samefile(left, right)
+    except (OSError, ValueError):
+        return False
+
+sys.exit(any(overlaps(cleaned, source) for cleaned in cleanup_aliases for source in source_paths))
+PY
+  then
+    usage_error "--output overlaps with game source inputs"
+  fi
+fi
+
+PERRY_TMP=""
+cleanup() {
+  if [[ -n "$PERRY_TMP" ]]; then
+    rm -rf "$PERRY_TMP"
+  fi
+}
+trap cleanup EXIT
+
 echo "=== Bloom Web Build ==="
+echo "  Profile: $BUILD_PROFILE"
 echo ""
 
 # 1. Build Bloom WASM via wasm-pack
-echo "[1/4] Building bloom_web.wasm..."
+echo "[1/3] Building bloom_web.wasm..."
 cd "$WEB_CRATE"
-wasm-pack build --target web --out-dir pkg --no-typescript 2>&1 | tail -3
+wasm-pack build --target web --out-dir pkg --no-typescript "$BUILD_PROFILE" 2>&1 | tail -3
 echo "  Output: $WEB_CRATE/pkg/"
 
-# 2. Optimize WASM binary (if wasm-opt is available)
-if command -v wasm-opt &> /dev/null; then
-  echo "[2/4] Optimizing WASM with wasm-opt..."
-  WASM_FILE="$WEB_CRATE/pkg/bloom_web_bg.wasm"
-  ORIG_SIZE=$(wc -c < "$WASM_FILE")
-  wasm-opt -Oz "$WASM_FILE" -o "$WASM_FILE.opt"
-  mv "$WASM_FILE.opt" "$WASM_FILE"
-  OPT_SIZE=$(wc -c < "$WASM_FILE")
-  echo "  Optimized: $((ORIG_SIZE / 1024))KB → $((OPT_SIZE / 1024))KB"
-else
-  echo "[2/4] Skipping wasm-opt (not installed). Install with: cargo install wasm-opt"
-fi
-
-# 3. Compile game (if provided)
+# 2. Compile game (if provided)
 PERRY_HTML=""
 if [ -n "$GAME_FILE" ] && [ -f "$GAME_FILE" ]; then
-  echo "[3/4] Compiling game: $GAME_FILE"
+  echo "[2/3] Compiling game: $GAME_FILE"
 
   # Find perry compiler
   PERRY=""
@@ -78,16 +191,21 @@ if [ -n "$GAME_FILE" ] && [ -f "$GAME_FILE" ]; then
   # Use a temp dir (portable across GNU/BSD mktemp) so cleanup is a single rm.
   PERRY_TMP="$(mktemp -d)"
   PERRY_HTML="$PERRY_TMP/game.html"
-  $PERRY "$GAME_FILE" --target wasm -o "$PERRY_HTML"
+  "$PERRY" "$GAME_FILE" --target wasm -o "$PERRY_HTML"
   echo "  Game compiled to WASM ($PERRY_HTML)"
 else
-  echo "[3/4] No game file specified, skipping game compilation"
+  echo "[2/3] No game file specified, skipping game compilation"
 fi
 
-# 4. Assemble output directory
-echo "[4/4] Assembling output..."
+# 3. Assemble output directory
+echo "[3/3] Assembling output..."
 mkdir -p "$OUTPUT_DIR"
 
+# Replace artifacts owned by this build so repeated builds never nest pkg or
+# assets directories, or leave stale files from the previous game/profile.
+rm -rf "$OUTPUT_DIR/pkg" "$OUTPUT_DIR/assets"
+rm -f "$OUTPUT_DIR/index.html" "$OUTPUT_DIR/bloom_glue.js" "$OUTPUT_DIR/jolt_bridge.js"
+
 # Copy Bloom WASM package
 cp -r "$WEB_CRATE/pkg" "$OUTPUT_DIR/pkg"
 
@@ -99,7 +217,6 @@ if [ -n "$PERRY_HTML" ]; then
   # Game build: splice the Bloom bootstrap into Perry's HTML and gate the game's
   # bootPerryWasm() call on engine readiness → dist/web/index.html.
   python3 "$WEB_CRATE/splice_game.py" "$PERRY_HTML" "$OUTPUT_DIR/index.html"
-  rm -rf "$PERRY_TMP"
   echo "  Spliced game + engine into index.html"
 else
   # No game: ship the engine-only standalone page.
@@ -109,7 +226,6 @@ fi
 
 # Copy game assets (if game directory has an assets/ folder)
 if [ -n "$GAME_FILE" ]; then
-  GAME_DIR="$(dirname "$(realpath "$GAME_FILE")")"
   if [ -d "$GAME_DIR/assets" ]; then
     cp -r "$GAME_DIR/assets" "$OUTPUT_DIR/assets"
     echo "  Copied assets/ directory"

package/native/web/src/lib.rs

@@ -313,7 +313,9 @@ pub fn bloom_get_time() -> f64 {
 // in input_ffi.rs (2000-line file policy).
 mod input_ffi;
 mod material_ffi;
+mod ui_ffi;
 pub use input_ffi::*;
+pub use ui_ffi::*;
 
 // EN-063 — web FFI parity for full-3D games: mesh/instance/texture-array
 // scratch builders, staged-model bytes, env-HDR bytes, profiler text,

package/native/web/src/ui_ffi.rs

@@ -0,0 +1,148 @@
+use super::engine;
+use bloom_shared::ui::{UiBackend, UiCommand, UiOpcode};
+use wasm_bindgen::prelude::*;
+
+#[wasm_bindgen]
+pub fn bloom_ui_command_str(
+    backend: f64,
+    opcode: f64,
+    id: f64,
+    a: f64,
+    b: f64,
+    c: f64,
+    d: f64,
+    text: &str,
+) -> f64 {
+    let Some(backend) = UiBackend::from_abi(backend) else {
+        return 0.0;
+    };
+    let Some(opcode) = UiOpcode::from_abi(opcode) else {
+        return 0.0;
+    };
+    let Some(id) = bloom_shared::ui::id_from_abi(id) else {
+        return 0.0;
+    };
+    if engine()
+        .ui
+        .queue_command(UiCommand::new(backend, opcode, id, [a, b, c, d], text))
+    {
+        1.0
+    } else {
+        0.0
+    }
+}
+
+#[wasm_bindgen]
+pub fn bloom_ui_scratch_reset(backend: f64) {
+    if let Some(backend) = UiBackend::from_abi(backend) {
+        engine().ui.reset_scratch(backend);
+    }
+}
+
+#[wasm_bindgen]
+pub fn bloom_ui_scratch_push_f64(backend: f64, value: f64) {
+    if let Some(backend) = UiBackend::from_abi(backend) {
+        engine().ui.push_scratch(backend, value);
+    }
+}
+
+#[wasm_bindgen]
+pub fn bloom_ui_scratch_command_str(
+    backend: f64,
+    opcode: f64,
+    id: f64,
+    count: f64,
+    text: &str,
+) -> f64 {
+    let Some(backend) = UiBackend::from_abi(backend) else {
+        return 0.0;
+    };
+    let Some(opcode) = UiOpcode::from_abi(opcode) else {
+        return 0.0;
+    };
+    let Some(id) = bloom_shared::ui::id_from_abi(id) else {
+        return 0.0;
+    };
+    let Some(count) = bloom_shared::ui::id_from_abi(count) else {
+        return 0.0;
+    };
+    if engine()
+        .ui
+        .queue_scratch_command(backend, opcode, id, count as usize, text)
+    {
+        1.0
+    } else {
+        0.0
+    }
+}
+
+#[wasm_bindgen]
+pub fn bloom_ui_inject_text_str(text: &str) {
+    engine().ui.inject_text(text.to_owned());
+}
+
+#[wasm_bindgen]
+pub fn bloom_ui_response(backend: f64, id: f64, field: f64) -> f64 {
+    let Some(backend) = UiBackend::from_abi(backend) else {
+        return 0.0;
+    };
+    let Some(id) = bloom_shared::ui::id_from_abi(id) else {
+        return 0.0;
+    };
+    let Some(field) = bloom_shared::ui::id_from_abi(field) else {
+        return 0.0;
+    };
+    let response = engine().ui.response(backend, id);
+    match field {
+        0 => response.clicked as u8 as f64,
+        1 => response.changed as u8 as f64,
+        2 => response.hovered as u8 as f64,
+        3 => response.focused as u8 as f64,
+        4 => response.dragged as u8 as f64,
+        5 => response.value,
+        6 => engine().ui.has_response(backend, id) as u8 as f64,
+        _ => 0.0,
+    }
+}
+
+#[wasm_bindgen]
+pub fn bloom_ui_response_text(backend: f64, id: f64) -> String {
+    let Some(backend) = UiBackend::from_abi(backend) else {
+        return String::new();
+    };
+    let Some(id) = bloom_shared::ui::id_from_abi(id) else {
+        return String::new();
+    };
+    engine().ui.response_text(backend, id)
+}
+
+#[wasm_bindgen]
+pub fn bloom_ui_is_available(backend: f64) -> f64 {
+    let Some(backend) = UiBackend::from_abi(backend) else {
+        return 0.0;
+    };
+    engine().ui.is_available(backend) as u8 as f64
+}
+
+#[wasm_bindgen]
+pub fn bloom_ui_wants_input(backend: f64, kind: f64) -> f64 {
+    let Some(backend) = UiBackend::from_abi(backend) else {
+        return 0.0;
+    };
+    let Some(kind) = bloom_shared::ui::id_from_abi(kind) else {
+        return 0.0;
+    };
+    engine().ui.wants_input(backend, kind) as u8 as f64
+}
+
+#[wasm_bindgen]
+pub fn bloom_ui_take_keyboard_request(backend: f64) -> f64 {
+    let Some(UiBackend::Egui) = UiBackend::from_abi(backend) else {
+        return -1.0;
+    };
+    match engine().ui.take_keyboard_request() {
+        Some(true) => 1.0,
+        Some(false) => 0.0,
+        None => -1.0,
+    }
+}