@bornengine/engine 0.4.16 → 0.5.1

package/native/windows/Cargo.toml

@@ -26,6 +26,9 @@ jolt = ["bloom-shared/jolt"]
 # unaffected; pure-2D games opt out via Perry feature forwarding.
 models3d = ["bloom-shared/models3d"]
 image-extras = ["bloom-shared/image-extras"]
+hot-reload = ["bloom-shared/hot-reload"]
+dev = ["hot-reload"]
+debug-ui = ["bloom-shared/debug-ui"]
 
 # Match perry-runtime's panic strategy so perry's final lld-link doesn't see
 # two copies of `rust_eh_personality` (and friends) from two independent Rust

package/native/windows/src/lib.rs

@@ -5,6 +5,8 @@ use bloom_shared::audio::{parse_wav, parse_ogg, parse_mp3};
 
 use std::sync::OnceLock;
 
+mod windows_text;
+
 static mut ENGINE: OnceLock<EngineState> = OnceLock::new();
 
 /// True when the engine renders into a host-provided child window (a Perry UI
@@ -193,6 +195,8 @@ mod crash_report {
 #[cfg(windows)]
 mod win32 {
     use super::*;
+    use super::windows_text::WindowsTextDecoder;
+    use std::cell::RefCell;
     use windows::Win32::UI::WindowsAndMessaging::*;
     use windows::Win32::UI::HiDpi::*;
     use windows::Win32::Foundation::*;
@@ -212,6 +216,33 @@ mod win32 {
     static mut WINDOWED_STYLE: u32 = 0;
     static mut WINDOWED_RECT: RECT = RECT { left: 0, top: 0, right: 0, bottom: 0 };
 
+    thread_local! {
+        static TEXT_DECODER: RefCell<WindowsTextDecoder> = RefCell::new(WindowsTextDecoder::default());
+    }
+
+    fn queue_text_message(msg: u32, wparam: WPARAM) -> Option<LRESULT> {
+        if msg == WM_UNICHAR && wparam.0 as u32 == UNICODE_NOCHAR {
+            return Some(LRESULT(1));
+        }
+
+        let characters = match msg {
+            WM_CHAR => TEXT_DECODER.with(|decoder| {
+                decoder.borrow_mut().decode_char_unit(wparam.0 as u16)
+            }),
+            WM_UNICHAR => TEXT_DECODER.with(|decoder| {
+                decoder.borrow_mut().decode_unichar(wparam.0 as u32)
+            }),
+            _ => return None,
+        };
+
+        if let Some(engine) = unsafe { ENGINE.get_mut() } {
+            for character in characters {
+                engine.input.push_char(character as u32);
+            }
+        }
+        Some(LRESULT(0))
+    }
+
     pub fn set_fullscreen(fullscreen: bool) {
         unsafe {
             let Some(hwnd) = HWND_GLOBAL else { return };
@@ -257,6 +288,9 @@ mod win32 {
     }
 
     unsafe extern "system" fn wndproc(hwnd: HWND, msg: u32, wparam: WPARAM, lparam: LPARAM) -> LRESULT {
+        if let Some(result) = queue_text_message(msg, wparam) {
+            return result;
+        }
         match msg {
             WM_CLOSE => {
                 // Diagnostic (title-freeze investigation): who closes us?
@@ -520,6 +554,11 @@ mod win32 {
         wparam: WPARAM,
         lparam: LPARAM,
     ) -> LRESULT {
+        if let Some(result) = queue_text_message(msg, wparam) {
+            if msg == WM_UNICHAR && wparam.0 as u32 == UNICODE_NOCHAR {
+                return result;
+            }
+        }
         match msg {
             0x0005 /* WM_SIZE */ => {
                 let phys_w = (lparam.0 & 0xFFFF) as u32;
@@ -640,6 +679,11 @@ unsafe fn init_engine_for_hwnd(
             let mut handle = raw_window_handle::Win32WindowHandle::new(
                 std::num::NonZeroIsize::new(hwnd.0 as isize).unwrap()
             );
+            handle.hinstance = std::num::NonZeroIsize::new(
+                windows::Win32::System::LibraryLoader::GetModuleHandleW(None)
+                    .unwrap()
+                    .0 as isize,
+            );
             let raw = raw_window_handle::RawWindowHandle::Win32(handle);
             instance.create_surface_unsafe(wgpu::SurfaceTargetUnsafe::RawHandle {
                 raw_display_handle: Some(raw_window_handle::RawDisplayHandle::Windows(
@@ -862,7 +906,12 @@ pub extern "C" fn bloom_attach_native(handle: i64, width: f64, height: f64) -> f
             return 0.0;
         };
         let target = {
-            let h = raw_window_handle::Win32WindowHandle::new(hwnd_nz);
+            let mut h = raw_window_handle::Win32WindowHandle::new(hwnd_nz);
+            h.hinstance = std::num::NonZeroIsize::new(unsafe {
+                windows::Win32::System::LibraryLoader::GetModuleHandleW(None)
+                    .unwrap()
+                    .0 as isize
+            });
             wgpu::SurfaceTargetUnsafe::RawHandle {
                 raw_display_handle: Some(raw_window_handle::RawDisplayHandle::Windows(
                     raw_window_handle::WindowsDisplayHandle::new(),

package/native/windows/src/windows_text.rs

@@ -0,0 +1,69 @@
+#[derive(Default)]
+pub(crate) struct WindowsTextDecoder {
+    pending_high_surrogate: Option<u16>,
+}
+
+impl WindowsTextDecoder {
+    pub(crate) fn decode_char_unit(&mut self, unit: u16) -> Vec<char> {
+        let mut characters = Vec::with_capacity(2);
+        match unit {
+            0xD800..=0xDBFF => {
+                if self.pending_high_surrogate.replace(unit).is_some() {
+                    characters.push('\u{FFFD}');
+                }
+            }
+            0xDC00..=0xDFFF => {
+                if let Some(high) = self.pending_high_surrogate.take() {
+                    let scalar =
+                        0x1_0000 + ((u32::from(high) - 0xD800) << 10) + (u32::from(unit) - 0xDC00);
+                    characters.push(char::from_u32(scalar).unwrap_or('\u{FFFD}'));
+                } else {
+                    characters.push('\u{FFFD}');
+                }
+            }
+            _ => {
+                if self.pending_high_surrogate.take().is_some() {
+                    characters.push('\u{FFFD}');
+                }
+                if let Some(character) = char::from_u32(u32::from(unit)) {
+                    characters.push(character);
+                }
+            }
+        }
+        characters.retain(|character| !character.is_control());
+        characters
+    }
+
+    pub(crate) fn decode_unichar(&mut self, scalar: u32) -> Vec<char> {
+        let mut characters = Vec::with_capacity(2);
+        if self.pending_high_surrogate.take().is_some() {
+            characters.push('\u{FFFD}');
+        }
+        if let Some(character) = char::from_u32(scalar) {
+            characters.push(character);
+        }
+        characters.retain(|character| !character.is_control());
+        characters
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::WindowsTextDecoder;
+
+    #[test]
+    fn windows_text_decoder_combines_utf16_surrogate_pairs() {
+        let mut decoder = WindowsTextDecoder::default();
+
+        assert!(decoder.decode_char_unit(0xD83D).is_empty());
+        assert_eq!(decoder.decode_char_unit(0xDE00), ['😀']);
+    }
+
+    #[test]
+    fn windows_text_decoder_accepts_bmp_and_unichar_codepoints() {
+        let mut decoder = WindowsTextDecoder::default();
+
+        assert_eq!(decoder.decode_char_unit('é' as u16), ['é']);
+        assert_eq!(decoder.decode_unichar(0x1F680), ['🚀']);
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bornengine/engine",
-  "version": "0.4.16",
+  "version": "0.5.1",
   "description": "BornEngine: native TypeScript game engine compiled by Perry",
   "main": "src/index.ts",
   "types": "src/index.ts",
@@ -17,7 +17,10 @@
     "./scene": "./src/scene/index.ts",
     "./physics": "./src/physics/index.ts",
     "./world": "./src/world/index.ts",
-    "./vfx": "./src/vfx/index.ts"
+    "./vfx": "./src/vfx/index.ts",
+    "./game": "./src/game/index.ts",
+    "./ui": "./src/ui/index.ts",
+    "./debug-ui": "./src/debug-ui/index.ts"
   },
   "files": [
     "src/",
@@ -157,6 +160,92 @@
           "params": [],
           "returns": "void"
         },
+        {
+          "name": "bloom_ui_command",
+          "params": [
+            "f64",
+            "f64",
+            "f64",
+            "f64",
+            "f64",
+            "f64",
+            "f64",
+            "string"
+          ],
+          "returns": "f64"
+        },
+        {
+          "name": "bloom_ui_scratch_reset",
+          "params": [
+            "f64"
+          ],
+          "returns": "void"
+        },
+        {
+          "name": "bloom_ui_scratch_push_f64",
+          "params": [
+            "f64",
+            "f64"
+          ],
+          "returns": "void"
+        },
+        {
+          "name": "bloom_ui_scratch_command",
+          "params": [
+            "f64",
+            "f64",
+            "f64",
+            "f64",
+            "string"
+          ],
+          "returns": "f64"
+        },
+        {
+          "name": "bloom_ui_inject_text",
+          "params": [
+            "string"
+          ],
+          "returns": "void"
+        },
+        {
+          "name": "bloom_ui_response",
+          "params": [
+            "f64",
+            "f64",
+            "f64"
+          ],
+          "returns": "f64"
+        },
+        {
+          "name": "bloom_ui_response_text",
+          "params": [
+            "f64",
+            "f64"
+          ],
+          "returns": "string"
+        },
+        {
+          "name": "bloom_ui_is_available",
+          "params": [
+            "f64"
+          ],
+          "returns": "f64"
+        },
+        {
+          "name": "bloom_ui_wants_input",
+          "params": [
+            "f64",
+            "f64"
+          ],
+          "returns": "f64"
+        },
+        {
+          "name": "bloom_ui_take_keyboard_request",
+          "params": [
+            "f64"
+          ],
+          "returns": "f64"
+        },
         {
           "name": "bloom_take_screenshot",
           "params": [

package/src/debug-ui/index.ts

@@ -0,0 +1,4 @@
+import { createUiApi } from '../ui/api';
+
+export const debugUi = createUiApi(1);
+export type { DebugUiApi, UiId, UiResponse, UiColor } from './types';

package/src/debug-ui/types.ts

@@ -0,0 +1 @@
+export type { UiApi as DebugUiApi, UiId, UiResponse, UiColor } from '../ui/types';

package/src/game/adapters/audio-source-component.ts

@@ -0,0 +1,67 @@
+import { playSound3DEx, voiceSetPosition, voiceStop } from '../../audio';
+import type { Sound } from '../../core/types';
+import { GameComponent } from '../game-component';
+import type { GameObject } from '../game-object';
+
+export interface AudioSourceComponentOptions {
+  looping?: boolean;
+  refDist?: number;
+  maxDist?: number;
+  rolloff?: number;
+}
+
+/** Plays a shared Sound asset through a voice owned by this component. */
+export class AudioSourceComponent extends GameComponent {
+  readonly sound: Sound;
+  readonly looping: boolean;
+  readonly refDist: number;
+  readonly maxDist: number;
+  readonly rolloff: number;
+  private voice = 0;
+
+  constructor(sound: Sound, options: AudioSourceComponentOptions = {}) {
+    super();
+    this.sound = sound;
+    this.looping = options.looping === undefined ? false : options.looping;
+    this.refDist = options.refDist === undefined ? 1 : options.refDist;
+    this.maxDist = options.maxDist === undefined ? 0 : options.maxDist;
+    this.rolloff = options.rolloff === undefined ? 1 : options.rolloff;
+  }
+
+  play(): boolean {
+    this.stop();
+    if (this.destroyed) return false;
+    const owner: GameObject | null = this.gameObject;
+    if (owner === null || owner.destroyed) return false;
+    const position = owner.transform.worldPosition;
+    this.voice = playSound3DEx(
+      this.sound,
+      position.x,
+      position.y,
+      position.z,
+      this.looping,
+      this.refDist,
+      this.maxDist,
+      this.rolloff,
+    );
+    return this.voice !== 0;
+  }
+
+  stop(): void {
+    if (this.voice === 0) return;
+    voiceStop(this.voice);
+    this.voice = 0;
+  }
+
+  _syncRuntimeAfterPhase(): void {
+    if (this.voice === 0 || this.destroyed) return;
+    const owner: GameObject | null = this.gameObject;
+    if (owner === null || owner.destroyed) return;
+    const position = owner.transform.worldPosition;
+    voiceSetPosition(this.voice, position.x, position.y, position.z);
+  }
+
+  onDestroy(): void {
+    this.stop();
+  }
+}

package/src/game/adapters/rigid-body-component.ts

@@ -0,0 +1,69 @@
+import { GameComponent } from '../game-component';
+import type { GameObject } from '../game-object';
+import {
+  destroyBody,
+  getBodyTransform,
+  isBodyValid,
+  MotionType,
+  moveKinematic,
+  setBodyTransform,
+} from '../../physics';
+import type { BodyHandle, WorldHandle } from '../../physics';
+
+export type RigidBodyMotionType = typeof MotionType[keyof typeof MotionType];
+
+export interface RigidBodyComponentOptions {
+  motionType: RigidBodyMotionType;
+  ownership?: 'borrowed' | 'owned';
+}
+
+/** Wraps an existing physics body; the world and shape remain externally owned. */
+export class RigidBodyComponent extends GameComponent {
+  readonly world: WorldHandle;
+  readonly body: BodyHandle;
+  readonly motionType: RigidBodyMotionType;
+  readonly ownership: 'borrowed' | 'owned';
+
+  constructor(
+    world: WorldHandle,
+    body: BodyHandle,
+    options: RigidBodyComponentOptions,
+  ) {
+    super();
+    this.world = world;
+    this.body = body;
+    this.motionType = options.motionType;
+    this.ownership = options.ownership || 'borrowed';
+  }
+
+  _syncPhysicsBeforeStep(world: number, fixedDt: number): void {
+    if (this.destroyed || this.world !== world || !isBodyValid(this.body)) return;
+    const owner: GameObject | null = this.gameObject;
+    if (owner === null || owner.destroyed) return;
+    const pose = {
+      position: owner.transform.worldPosition,
+      rotation: owner.transform.worldRotation,
+    };
+    if (this.motionType === MotionType.STATIC) {
+      setBodyTransform(this.body, pose);
+    } else if (this.motionType === MotionType.KINEMATIC) {
+      moveKinematic(this.body, pose, fixedDt);
+    }
+  }
+
+  _syncPhysicsAfterStep(world: number): void {
+    if (this.destroyed || this.world !== world ||
+        this.motionType !== MotionType.DYNAMIC || !isBodyValid(this.body)) return;
+    const owner: GameObject | null = this.gameObject;
+    if (owner === null || owner.destroyed) return;
+    const pose = getBodyTransform(this.body);
+    if (!owner.transform.setWorldPosition(pose.position)) return;
+    owner.transform.setWorldRotation(pose.rotation);
+  }
+
+  onDestroy(): void {
+    if (this.ownership === 'owned' && isBodyValid(this.body)) {
+      destroyBody(this.body);
+    }
+  }
+}

package/src/game/adapters/scene-node-component.ts

@@ -0,0 +1,49 @@
+import { GameComponent } from '../game-component';
+import type { GameObject } from '../game-object';
+import {
+  destroySceneNode,
+  setSceneNodeParent,
+  setSceneNodeTransform,
+} from '../../scene';
+import type { SceneNodeHandle } from '../../scene';
+
+export interface SceneNodeComponentOptions {
+  ownership?: 'borrowed' | 'owned';
+}
+
+/** Wraps an existing renderer scene node without creating one implicitly. */
+export class SceneNodeComponent extends GameComponent {
+  readonly handle: SceneNodeHandle;
+  readonly ownership: 'borrowed' | 'owned';
+
+  constructor(handle: SceneNodeHandle, options: SceneNodeComponentOptions = {}) {
+    super();
+    this.handle = handle;
+    this.ownership = options.ownership || 'borrowed';
+  }
+
+  _syncRuntimeAfterPhase(): void {
+    const owner: GameObject | null = this.gameObject;
+    if (owner === null || this.destroyed) return;
+    const parent = owner.parent;
+    const parentAdapter = parent === null
+      ? null
+      : parent.getComponent(SceneNodeComponent);
+    if (parentAdapter !== null && !parentAdapter.destroyed) {
+      setSceneNodeParent(this.handle, parentAdapter.handle);
+      setSceneNodeTransform(this.handle, owner.transform.localMatrix);
+    } else {
+      setSceneNodeParent(this.handle, 0);
+      setSceneNodeTransform(this.handle, owner.transform.worldMatrix);
+    }
+  }
+
+  onDestroy(): void {
+    const owner: GameObject | null = this.gameObject;
+    if (owner !== null) {
+      setSceneNodeParent(this.handle, 0);
+      setSceneNodeTransform(this.handle, owner.transform.worldMatrix);
+    }
+    if (this.ownership === 'owned') destroySceneNode(this.handle);
+  }
+}

package/src/game/game-component.ts

@@ -0,0 +1,89 @@
+import type { GameObject } from './game-object';
+import type { WorldHandle } from '../physics';
+
+export type GameComponentType<T extends GameComponent> =
+  new (...args: any[]) => T;
+
+export class GameComponent {
+  enabled = true;
+  private owner: GameObject | null = null;
+  private wasDestroyed = false;
+  private isDestroying = false;
+  private destroyCallbackStarted = false;
+  private wasAwake = false;
+  private wasStarted = false;
+
+  get gameObject(): GameObject | null {
+    return this.owner;
+  }
+
+  get isActiveAndEnabled(): boolean {
+    return this.owner !== null && this.enabled && !this.destroyed &&
+      this.owner.activeInHierarchy;
+  }
+
+  get destroyed(): boolean {
+    return this.wasDestroyed || this.isDestroying;
+  }
+
+  onAwake(): void {}
+
+  onStart(): void {}
+
+  update(_dt: number): void {}
+
+  fixedUpdate(_dt: number): void {}
+
+  onDestroy(): void {}
+
+  /** @internal Synchronizes adapter state after a scene phase. */
+  _syncRuntimeAfterPhase(): void {}
+
+  /** @internal Pushes adapter state before a caller-owned physics step. */
+  _syncPhysicsBeforeStep(_world: WorldHandle, _fixedDt: number): void {}
+
+  /** @internal Pulls adapter state after a caller-owned physics step. */
+  _syncPhysicsAfterStep(_world: WorldHandle): void {}
+
+  /** @internal Assigns the single owning GameObject. */
+  _setGameObject(owner: GameObject): boolean {
+    if (this.owner !== null || this.destroyed) return false;
+    this.owner = owner;
+    return true;
+  }
+
+  /** @internal Starts the component's exactly-once destruction path. */
+  _beginDestroy(): boolean {
+    if (this.wasDestroyed || this.isDestroying) return false;
+    this.isDestroying = true;
+    return true;
+  }
+
+  /** @internal Ensures the component destruction callback runs only once. */
+  _beginDestroyCallback(): boolean {
+    if (this.destroyCallbackStarted) return false;
+    this.destroyCallbackStarted = true;
+    return true;
+  }
+
+  /** @internal Completes destruction after onDestroy returns. */
+  _finishDestroy(): void {
+    this.wasDestroyed = true;
+    this.isDestroying = false;
+    this.owner = null;
+  }
+
+  /** @internal Marks awake once per component lifetime. */
+  _markAwake(): boolean {
+    if (this.wasAwake) return false;
+    this.wasAwake = true;
+    return true;
+  }
+
+  /** @internal Marks start once per component lifetime. */
+  _markStarted(): boolean {
+    if (this.wasStarted) return false;
+    this.wasStarted = true;
+    return true;
+  }
+}