@bornengine/engine 0.4.16 → 0.5.1

package/src/game/game-object.ts

@@ -0,0 +1,338 @@
+import { Vec3, Quat } from '../core/types';
+import { mat4Multiply } from '../math';
+import { GameComponent, GameComponentType } from './game-component';
+import {
+  decomposeTransformMatrix,
+  invertTransformMatrix,
+  Transform,
+  TransformOptions,
+} from './transform';
+import type { GameScene } from './game-scene';
+
+export interface GameObjectOptions extends TransformOptions {
+  name?: string;
+  active?: boolean;
+}
+
+export interface ParentOptions {
+  preserveWorldTransform?: boolean;
+}
+
+let nextGameObjectId = 1;
+
+function copyVec3(value: Vec3): Vec3 {
+  return { x: value.x, y: value.y, z: value.z };
+}
+
+function copyQuat(value: Quat): Quat {
+  return { x: value.x, y: value.y, z: value.z, w: value.w };
+}
+
+function removeAt<T>(values: T[], index: number): void {
+  for (let current = index; current + 1 < values.length; current++) {
+    values[current] = values[current + 1];
+  }
+  values.pop();
+}
+
+export class GameObject {
+  readonly id: number;
+  readonly transform: Transform;
+  name: string;
+  active: boolean;
+
+  private ownerScene: GameScene | null = null;
+  private parentObject: GameObject | null = null;
+  private childObjects: GameObject[] = [];
+  private components: GameComponent[] = [];
+  private wasDestroyed = false;
+  private isDestroying = false;
+  private wasAwake = false;
+  private awakeningDepth = 0;
+  private wasStarted = false;
+  private attachmentGeneration = 0;
+
+  constructor(options: GameObjectOptions = {}) {
+    this.id = nextGameObjectId++;
+    this.name = options.name || '';
+    this.active = options.active === undefined ? true : options.active;
+    this.transform = new Transform({
+      position: options.position === undefined ? undefined : copyVec3(options.position),
+      rotation: options.rotation === undefined ? undefined : copyQuat(options.rotation),
+      scale: options.scale === undefined ? undefined : copyVec3(options.scale),
+    });
+  }
+
+  get activeInHierarchy(): boolean {
+    if (this.destroyed || !this.active) return false;
+    if (this.parentObject === null) return true;
+    return this.parentObject.activeInHierarchy;
+  }
+
+  get destroyed(): boolean {
+    return this.wasDestroyed || this.isDestroying;
+  }
+
+  get scene(): GameScene | null {
+    return this.ownerScene;
+  }
+
+  get parent(): GameObject | null {
+    return this.parentObject;
+  }
+
+  get children(): readonly GameObject[] {
+    return this.childObjects.slice();
+  }
+
+  onAwake(): void {}
+
+  onStart(): void {}
+
+  update(_dt: number): void {}
+
+  fixedUpdate(_dt: number): void {}
+
+  onDestroy(): void {}
+
+  addChild<T extends GameObject>(child: T, options: ParentOptions = {}): T | null {
+    if (this.destroyed || child.destroyed || child === this) return null;
+    if (child.parentObject === this) return child;
+
+    let ancestor: GameObject | null = this;
+    while (ancestor !== null) {
+      if (ancestor === child) return null;
+      ancestor = ancestor.parentObject;
+    }
+
+    const targetScene = this.ownerScene;
+    const childScene = child.ownerScene;
+    if (childScene !== null && childScene !== targetScene) return null;
+    if (targetScene === null && childScene !== null) return null;
+    if (targetScene !== null && childScene === null &&
+        !targetScene._canAttachSubtree(child)) return null;
+
+    let nextLocalPosition: Vec3 | null = null;
+    let nextLocalRotation: Quat | null = null;
+    let nextLocalScale: Vec3 | null = null;
+    if (options.preserveWorldTransform !== false) {
+      const childWorld = child.transform.worldMatrix;
+      const inverseParent = invertTransformMatrix(this.transform.worldMatrix);
+      if (inverseParent === null) return null;
+      const nextLocalMatrix = mat4Multiply(inverseParent, childWorld);
+      const localTRS = decomposeTransformMatrix(nextLocalMatrix);
+      if (localTRS === null) return null;
+      nextLocalPosition = localTRS.position;
+      nextLocalRotation = localTRS.rotation;
+      nextLocalScale = localTRS.scale;
+    }
+
+    const previousParent = child.parentObject;
+    if (!child._setParent(this)) return null;
+    if (previousParent !== null) {
+      const previousIndex = previousParent.childObjects.indexOf(child);
+      if (previousIndex >= 0) removeAt(previousParent.childObjects, previousIndex);
+    }
+    this.childObjects.push(child);
+    if (nextLocalPosition !== null && nextLocalRotation !== null &&
+        nextLocalScale !== null) {
+      child.transform._setLocalTRS(nextLocalPosition, nextLocalRotation, nextLocalScale);
+    }
+    if (targetScene !== null && childScene === null) {
+      targetScene._attachSubtree(child);
+    }
+    return child;
+  }
+
+  removeChild(child: GameObject, options: ParentOptions = {}): boolean {
+    if (this.destroyed || child.destroyed || child.parentObject !== this) return false;
+
+    let nextLocalPosition: Vec3 | null = null;
+    let nextLocalRotation: Quat | null = null;
+    let nextLocalScale: Vec3 | null = null;
+    if (options.preserveWorldTransform !== false) {
+      const worldTRS = decomposeTransformMatrix(child.transform.worldMatrix);
+      if (worldTRS === null) return false;
+      nextLocalPosition = worldTRS.position;
+      nextLocalRotation = worldTRS.rotation;
+      nextLocalScale = worldTRS.scale;
+    }
+
+    const index = this.childObjects.indexOf(child);
+    if (index < 0 || !child._setParent(null)) return false;
+    removeAt(this.childObjects, index);
+    if (nextLocalPosition !== null && nextLocalRotation !== null &&
+        nextLocalScale !== null) {
+      child.transform._setLocalTRS(nextLocalPosition, nextLocalRotation, nextLocalScale);
+    }
+    return true;
+  }
+
+  addComponent<T extends GameComponent>(component: T): T | null {
+    if (this.destroyed || component.destroyed || component.gameObject !== null) return null;
+    if (!component._setGameObject(this)) return null;
+    this.components.push(component);
+    if (this.wasAwake && this.awakeningDepth === 0 && component._markAwake()) {
+      const dynamicComponent: any = component;
+      dynamicComponent.onAwake();
+    }
+    return component;
+  }
+
+  getComponent<T extends GameComponent>(type: GameComponentType<T>): T | null {
+    for (let index = 0; index < this.components.length; index++) {
+      const component = this.components[index];
+      if (component instanceof type) return component as T;
+    }
+    return null;
+  }
+
+  getComponents<T extends GameComponent>(type: GameComponentType<T>): T[] {
+    const result: T[] = [];
+    for (let index = 0; index < this.components.length; index++) {
+      const component = this.components[index];
+      if (component instanceof type) result.push(component as T);
+    }
+    return result;
+  }
+
+  removeComponent(component: GameComponent): boolean {
+    if (component.gameObject !== this || !component._beginDestroy()) return false;
+    if (component._beginDestroyCallback()) {
+      // Perry's statically-known cross-module calls can bypass subclass
+      // overrides. Keep this callback dynamic so user component classes dispatch.
+      const dynamicComponent: any = component;
+      dynamicComponent.onDestroy();
+    }
+    component._finishDestroy();
+    const index = this.components.indexOf(component);
+    if (index >= 0) removeAt(this.components, index);
+    if (this.ownerScene !== null) this.ownerScene._syncSubtreeAdapters(this);
+    return true;
+  }
+
+  destroy(): boolean {
+    if (!this._beginDestroy()) return false;
+    this._markDescendantsDestroying();
+    this._destroyMarkedSubtree();
+    return true;
+  }
+
+  /** @internal Links the transform hierarchy after GameObject validation. */
+  _setParent(parent: GameObject | null): boolean {
+    let current = parent;
+    while (current !== null) {
+      if (current === this) return false;
+      current = current.parentObject;
+    }
+    if (!this.transform._setParent(parent === null ? null : parent.transform)) return false;
+    this.parentObject = parent;
+    return true;
+  }
+
+  /** @internal Assigns scene ownership to the object. */
+  _setScene(scene: GameScene | null): void {
+    this.ownerScene = scene;
+  }
+
+  /** @internal Returns a stable component list for scene dispatch. */
+  _componentsSnapshot(): GameComponent[] {
+    return this.components.slice();
+  }
+
+  /** @internal Returns a stable child list for scene traversal. */
+  _childrenSnapshot(): GameObject[] {
+    return this.childObjects.slice();
+  }
+
+  /** @internal Marks the current scene attachment generation. */
+  _setAttachmentGeneration(generation: number): void {
+    this.attachmentGeneration = generation;
+  }
+
+  /** @internal Reads the generation captured in a dispatch snapshot. */
+  _getAttachmentGeneration(): number {
+    return this.attachmentGeneration;
+  }
+
+  /** @internal Marks awake once per object lifetime. */
+  _markAwake(): boolean {
+    if (this.wasAwake) return false;
+    this.wasAwake = true;
+    return true;
+  }
+
+  /** @internal Tracks the hierarchy traversal that dispatches awake callbacks. */
+  _beginAwakening(): void {
+    this.awakeningDepth++;
+  }
+
+  /** @internal Ends one hierarchy traversal that dispatches awake callbacks. */
+  _endAwakening(): void {
+    if (this.awakeningDepth > 0) this.awakeningDepth--;
+  }
+
+  /** @internal Marks start once per object lifetime. */
+  _markStarted(): boolean {
+    if (this.wasStarted) return false;
+    this.wasStarted = true;
+    return true;
+  }
+
+  /** @internal Starts the object's exactly-once destruction path. */
+  _beginDestroy(): boolean {
+    if (this.wasDestroyed || this.isDestroying) return false;
+    this.isDestroying = true;
+    return true;
+  }
+
+  /** @internal Completes destruction after all hooks return. */
+  _finishDestroy(): void {
+    this.wasDestroyed = true;
+    this.isDestroying = false;
+  }
+
+  private _markDescendantsDestroying(): void {
+    const components = this.components.slice();
+    for (let index = 0; index < components.length; index++) {
+      components[index]._beginDestroy();
+    }
+    const children = this.childObjects.slice();
+    for (let index = 0; index < children.length; index++) {
+      if (children[index]._beginDestroy()) {
+        children[index]._markDescendantsDestroying();
+      }
+    }
+  }
+
+  private _destroyMarkedSubtree(): void {
+    const children = this.childObjects.slice();
+    for (let index = 0; index < children.length; index++) {
+      children[index]._destroyMarkedSubtree();
+    }
+
+    const dynamicObject: any = this;
+    dynamicObject.onDestroy();
+
+    const components = this.components.slice();
+    for (let index = components.length - 1; index >= 0; index--) {
+      const component = components[index];
+      if (component._beginDestroyCallback()) {
+        const dynamicComponent: any = component;
+        dynamicComponent.onDestroy();
+      }
+      component._finishDestroy();
+      const componentIndex = this.components.indexOf(component);
+      if (componentIndex >= 0) removeAt(this.components, componentIndex);
+    }
+
+    const previousParent = this.parentObject;
+    if (previousParent !== null) {
+      const childIndex = previousParent.childObjects.indexOf(this);
+      if (childIndex >= 0) removeAt(previousParent.childObjects, childIndex);
+    }
+    this._setParent(null);
+    if (this.ownerScene !== null) this.ownerScene._removeDestroyedObject(this);
+    this._finishDestroy();
+  }
+}

package/src/game/game-scene.ts

@@ -0,0 +1,303 @@
+import { GameComponent } from './game-component';
+import { GameObject } from './game-object';
+import type { WorldHandle } from '../physics';
+
+function removeAt<T>(values: T[], index: number): void {
+  for (let current = index; current + 1 < values.length; current++) {
+    values[current] = values[current + 1];
+  }
+  values.pop();
+}
+
+export class GameScene {
+  private sceneObjects: GameObject[] = [];
+  private pendingAwakeRoots: GameObject[] = [];
+  private isAwakening = false;
+  private nextAttachmentGeneration = 1;
+  private wasDestroyed = false;
+
+  get objects(): readonly GameObject[] {
+    return this.sceneObjects.slice();
+  }
+
+  add<T extends GameObject>(object: T): T | null {
+    if (this.wasDestroyed || object.destroyed || object.scene !== null || object.parent !== null ||
+        !this._canAttachSubtree(object)) {
+      return null;
+    }
+    return this._attachSubtree(object) ? object : null;
+  }
+
+  remove(object: GameObject): boolean {
+    if (this.wasDestroyed || object.destroyed || object.scene !== this) return false;
+    if (object.parent !== null && !object.parent.removeChild(object)) return false;
+
+    const subtree = this._collectSubtree(object);
+    for (let index = this.sceneObjects.length - 1; index >= 0; index--) {
+      if (subtree.indexOf(this.sceneObjects[index]) >= 0) {
+        removeAt(this.sceneObjects, index);
+      }
+    }
+    for (let index = 0; index < subtree.length; index++) {
+      subtree[index]._setScene(null);
+    }
+    this._syncSubtreeAdapters(object);
+    return true;
+  }
+
+  update(dt: number): void {
+    if (this.wasDestroyed) return;
+    const objects = this.sceneObjects.slice();
+    const generations: number[] = [];
+    const componentSnapshots: GameComponent[][] = [];
+    for (let index = 0; index < objects.length; index++) {
+      generations.push(objects[index]._getAttachmentGeneration());
+      componentSnapshots.push(objects[index]._componentsSnapshot());
+    }
+
+    for (let objectIndex = 0; objectIndex < objects.length; objectIndex++) {
+      const object = objects[objectIndex];
+      const generation = generations[objectIndex];
+      if (!this._isEligibleObject(object, generation)) continue;
+
+      if (object._markStarted()) {
+        const dynamicObject: any = object;
+        dynamicObject.onStart();
+      }
+      if (this._isEligibleObject(object, generation)) {
+        const dynamicObject: any = object;
+        dynamicObject.update(dt);
+      }
+
+      const components = componentSnapshots[objectIndex];
+      for (let componentIndex = 0; componentIndex < components.length; componentIndex++) {
+        const component = components[componentIndex];
+        if (!this._isEligibleComponent(object, component, generation)) continue;
+        if (component._markStarted()) {
+          const dynamicComponent: any = component;
+          dynamicComponent.onStart();
+        }
+        if (this._isEligibleComponent(object, component, generation)) {
+          const dynamicComponent: any = component;
+          dynamicComponent.update(dt);
+        }
+      }
+    }
+    this._syncRuntimeAdapters();
+  }
+
+  updateFixed(fixedDt: number): void {
+    if (this.wasDestroyed) return;
+    const objects = this.sceneObjects.slice();
+    const generations: number[] = [];
+    const componentSnapshots: GameComponent[][] = [];
+    for (let index = 0; index < objects.length; index++) {
+      generations.push(objects[index]._getAttachmentGeneration());
+      componentSnapshots.push(objects[index]._componentsSnapshot());
+    }
+
+    for (let objectIndex = 0; objectIndex < objects.length; objectIndex++) {
+      const object = objects[objectIndex];
+      const generation = generations[objectIndex];
+      if (!this._isEligibleObject(object, generation)) continue;
+
+      const dynamicObject: any = object;
+      dynamicObject.fixedUpdate(fixedDt);
+
+      const components = componentSnapshots[objectIndex];
+      for (let componentIndex = 0; componentIndex < components.length; componentIndex++) {
+        const component = components[componentIndex];
+        if (!this._isEligibleComponent(object, component, generation)) continue;
+        const dynamicComponent: any = component;
+        dynamicComponent.fixedUpdate(fixedDt);
+      }
+    }
+    this._syncRuntimeAdapters();
+  }
+
+  syncPhysicsBeforeStep(world: WorldHandle, fixedDt: number): void {
+    if (this.wasDestroyed) return;
+    const objects = this.sceneObjects.slice();
+    for (let objectIndex = 0; objectIndex < objects.length; objectIndex++) {
+      const object = objects[objectIndex];
+      if (object.scene !== this || object.destroyed) continue;
+      const components = object._componentsSnapshot();
+      for (let componentIndex = 0; componentIndex < components.length; componentIndex++) {
+        const component = components[componentIndex];
+        if (component.gameObject !== object || component.destroyed) continue;
+        const dynamicComponent: any = component;
+        dynamicComponent._syncPhysicsBeforeStep(world, fixedDt);
+      }
+    }
+  }
+
+  syncPhysicsAfterStep(world: WorldHandle): void {
+    if (this.wasDestroyed) return;
+    const objects = this.sceneObjects.slice();
+    for (let objectIndex = 0; objectIndex < objects.length; objectIndex++) {
+      const object = objects[objectIndex];
+      if (object.scene !== this || object.destroyed) continue;
+      const components = object._componentsSnapshot();
+      for (let componentIndex = 0; componentIndex < components.length; componentIndex++) {
+        const component = components[componentIndex];
+        if (component.gameObject !== object || component.destroyed) continue;
+        const dynamicComponent: any = component;
+        dynamicComponent._syncPhysicsAfterStep(world);
+      }
+    }
+    this._syncRuntimeAdapters();
+  }
+
+  destroy(): void {
+    if (this.wasDestroyed) return;
+    this.wasDestroyed = true;
+    const objects = this.sceneObjects.slice();
+    for (let index = 0; index < objects.length; index++) {
+      const object = objects[index];
+      if (object.scene === this && object.parent === null) object.destroy();
+    }
+  }
+
+  /** @internal Validates a detached subtree before an atomic scene attachment. */
+  _canAttachSubtree(root: GameObject): boolean {
+    const subtree = this._collectSubtree(root);
+    for (let index = 0; index < subtree.length; index++) {
+      if (subtree[index].destroyed || subtree[index].scene !== null) return false;
+    }
+    return true;
+  }
+
+  /** @internal Attaches a detached subtree in parent-first insertion order. */
+  _attachSubtree(root: GameObject): boolean {
+    if (this.wasDestroyed || !this._canAttachSubtree(root)) return false;
+    const subtree = this._collectSubtree(root);
+    for (let index = 0; index < subtree.length; index++) {
+      const object = subtree[index];
+      object._setScene(this);
+      object._setAttachmentGeneration(this.nextAttachmentGeneration++);
+      this.sceneObjects.push(object);
+    }
+    if (this.isAwakening) {
+      this.pendingAwakeRoots.push(root);
+    } else {
+      this.isAwakening = true;
+      this._awakenSubtree(root);
+      let pendingIndex = 0;
+      while (pendingIndex < this.pendingAwakeRoots.length) {
+        this._awakenSubtree(this.pendingAwakeRoots[pendingIndex]);
+        pendingIndex++;
+      }
+      this.pendingAwakeRoots.length = 0;
+      this.isAwakening = false;
+    }
+    return true;
+  }
+
+  /** @internal Removes an object after all of its destruction callbacks return. */
+  _removeDestroyedObject(object: GameObject): void {
+    const index = this.sceneObjects.indexOf(object);
+    if (index >= 0) removeAt(this.sceneObjects, index);
+    object._setScene(null);
+  }
+
+  /** @internal Synchronizes renderer nodes in a detached hierarchy. */
+  _syncSubtreeAdapters(root: GameObject): void {
+    const subtree = this._collectSubtree(root);
+    for (let index = 0; index < subtree.length; index++) {
+      if (!subtree[index].destroyed) this._syncObjectAdapters(subtree[index]);
+    }
+  }
+
+  private _awakenSubtree(object: GameObject): void {
+    if (object.destroyed || object.scene !== this) return;
+    object._beginAwakening();
+    if (object._markAwake()) {
+      const dynamicObject: any = object;
+      dynamicObject.onAwake();
+    }
+    if (object.destroyed || object.scene !== this) {
+      object._endAwakening();
+      return;
+    }
+
+    this._awakenComponents(object);
+    if (object.destroyed || object.scene !== this) {
+      object._endAwakening();
+      return;
+    }
+
+    const children = object._childrenSnapshot();
+    for (let index = 0; index < children.length; index++) {
+      this._awakenSubtree(children[index]);
+    }
+    if (!object.destroyed && object.scene === this) {
+      this._awakenComponents(object);
+    }
+    object._endAwakening();
+  }
+
+  private _awakenComponents(object: GameObject): void {
+    while (!object.destroyed && object.scene === this) {
+      const components = object._componentsSnapshot();
+      let next: GameComponent | null = null;
+      for (let index = 0; index < components.length; index++) {
+        const component = components[index];
+        if (component.gameObject !== object || component.destroyed) continue;
+        if (component._markAwake()) {
+          next = component;
+          break;
+        }
+      }
+      if (next === null) return;
+      const dynamicComponent: any = next;
+      dynamicComponent.onAwake();
+    }
+  }
+
+  private _isEligibleObject(object: GameObject, generation: number): boolean {
+    return object.scene === this && !object.destroyed &&
+      object._getAttachmentGeneration() === generation && object.activeInHierarchy;
+  }
+
+  private _isEligibleComponent(
+    object: GameObject,
+    component: GameComponent,
+    generation: number,
+  ): boolean {
+    return this._isEligibleObject(object, generation) &&
+      component.gameObject === object && !component.destroyed && component.enabled &&
+      object.activeInHierarchy;
+  }
+
+  private _syncRuntimeAdapters(): void {
+    for (let index = 0; index < this.sceneObjects.length; index++) {
+      const object = this.sceneObjects[index];
+      if (!object.destroyed && object.scene === this) {
+        this._syncObjectAdapters(object);
+      }
+    }
+  }
+
+  private _syncObjectAdapters(object: GameObject): void {
+    const components = object._componentsSnapshot();
+    for (let index = 0; index < components.length; index++) {
+      const component = components[index];
+      if (component.gameObject !== object || component.destroyed) continue;
+      const dynamicComponent: any = component;
+      dynamicComponent._syncRuntimeAfterPhase();
+    }
+  }
+
+  private _collectSubtree(root: GameObject): GameObject[] {
+    const result: GameObject[] = [];
+    const visit = (object: GameObject): void => {
+      result.push(object);
+      const children = object._childrenSnapshot();
+      for (let index = 0; index < children.length; index++) {
+        visit(children[index]);
+      }
+    };
+    visit(root);
+    return result;
+  }
+}

package/src/game/index.ts

@@ -0,0 +1,7 @@
+export * from './game-component';
+export * from './game-object';
+export * from './game-scene';
+export * from './transform';
+export * from './adapters/scene-node-component';
+export * from './adapters/rigid-body-component';
+export * from './adapters/audio-source-component';