refactor(engine): optimize SceneManager, Actor and ActorTree

Author: fraxken

.changeset/puny-papers-yell.md

@@ -0,0 +1,5 @@
+---
+"@jolly-pixel/engine": minor
+---
+
+Optimize SceneManager, Actor and ActorTree

packages/engine/src/actor/Actor.ts

@@ -95,6 +95,8 @@ export class Actor<
     else {
       this.world.sceneManager.tree.add(this);
     }
+
+    this.world.sceneManager.registerActor(this);
   }
 
   #initializeComponent(
@@ -220,6 +222,8 @@ export class Actor<
   }
 
   destroy() {
+    this.world.sceneManager.unregisterActor(this);
+
     for (let i = this.components.length - 1; i >= 0; i--) {
       this.components[i].destroy?.();
     }

packages/engine/src/actor/ActorTree.ts

@@ -93,8 +93,17 @@ export class ActorTree<
     const currentPattern = patternParts[patternIndex];
     const isLastPattern = patternIndex === patternParts.length - 1;
 
+    const matchers = new Map<string, (name: string) => boolean>();
     // eslint-disable-next-line func-style
-    const matchSinglePattern = (name: string, pattern: string) => pm(pattern)(name);
+    const matchSinglePattern = (name: string, pattern: string) => {
+      let matcher = matchers.get(pattern);
+      if (!matcher) {
+        matcher = pm(pattern);
+        matchers.set(pattern, matcher);
+      }
+
+      return matcher(name);
+    };
 
     if (currentPattern === "**") {
       if (isLastPattern) {
@@ -176,7 +185,7 @@ export class ActorTree<
         break;
       }
 
-      currentNode = [...currentNode.children].find(
+      currentNode = currentNode.children.find(
         (child) => child.name === parts[i]
       ) ?? null;
     }

packages/engine/src/systems/SceneManager.ts

@@ -8,38 +8,26 @@ import {
   ActorComponent,
   ActorTree
 } from "../actor/index.ts";
+import type { WorldDefaultContext } from "./World.ts";
 import type { Component } from "../components/types.ts";
 
 export type SceneEvents = {
   awake: [];
 };
 
-export interface SceneContract {
-  readonly tree: ActorTree<any>;
-
-  componentsToBeStarted: Component[];
-  componentsToBeDestroyed: Component[];
-
-  getSource(): THREE.Scene;
-  awake(): void;
-  beginFrame(): void;
-  update(deltaTime: number): void;
-  fixedUpdate(deltaTime: number): void;
-  endFrame(): void;
-  destroyActor(actor: Actor<any>): void;
-}
-
-export class SceneManager extends EventEmitter<
-  SceneEvents
-> implements SceneContract {
+export class SceneManager<
+  TContext = WorldDefaultContext
+> extends EventEmitter<SceneEvents> {
   default: THREE.Scene;
 
   componentsToBeStarted: Component[] = [];
   componentsToBeDestroyed: Component[] = [];
 
-  #cachedActors: Actor<any>[] = [];
+  #registeredActors: Set<Actor<TContext>> = new Set();
+  #actorsByName: Map<string, Actor<TContext>[]> = new Map();
+  #cachedActors: Actor<TContext>[] = [];
 
-  readonly tree = new ActorTree<any>({
+  readonly tree = new ActorTree<TContext>({
     addCallback: (actor) => this.default.add(actor.object3D),
     removeCallback: (actor) => this.default.remove(actor.object3D)
   });
@@ -66,20 +54,15 @@ export class SceneManager extends EventEmitter<
   }
 
   beginFrame() {
-    this.#cachedActors.length = 0;
-    for (const { actor } of this.tree.walk()) {
-      this.#cachedActors.push(actor);
-    }
-
-    const cachedActors = this.#cachedActors;
+    this.#cachedActors = Array.from(this.#registeredActors);
 
     let i = 0;
     while (i < this.componentsToBeStarted.length) {
       const component = this.componentsToBeStarted[i];
 
       // If the component to be started is part of an actor
       // which will not be updated, skip it until next loop
-      if (cachedActors.indexOf(component.actor) === -1) {
+      if (!this.#registeredActors.has(component.actor)) {
         i++;
         continue;
       }
@@ -111,7 +94,7 @@ export class SceneManager extends EventEmitter<
     });
     this.componentsToBeDestroyed.length = 0;
 
-    const actorToBeDestroyed: Actor<any>[] = [];
+    const actorToBeDestroyed: Actor<TContext>[] = [];
     this.#cachedActors.forEach((actor) => {
       if (actor.pendingForDestruction || actor.isDestroyed()) {
         actorToBeDestroyed.push(actor);
@@ -124,26 +107,71 @@ export class SceneManager extends EventEmitter<
   }
 
   destroyActor(
-    actor: Actor<any>
+    actor: Actor<TContext>
   ) {
     const childrenToDestroy = [...actor.children];
 
     childrenToDestroy.forEach((child) => {
       this.destroyActor(child);
     });
 
-    const cachedIndex = this.#cachedActors.indexOf(actor);
-    if (cachedIndex !== -1) {
-      this.#cachedActors.splice(cachedIndex, 1);
-    }
+    this.unregisterActor(actor);
 
     // NOTE: make sure to remove deeply into the tree
     this.tree.remove(actor);
     actor.destroy();
   }
 
+  registerActor(
+    actor: Actor<TContext>
+  ) {
+    this.#registeredActors.add(actor);
+
+    const actors = this.#actorsByName.get(actor.name);
+    if (actors) {
+      actors.push(actor);
+    }
+    else {
+      this.#actorsByName.set(actor.name, [actor]);
+    }
+  }
+
+  unregisterActor(
+    actor: Actor<TContext>
+  ) {
+    this.#registeredActors.delete(actor);
+
+    const actors = this.#actorsByName.get(actor.name);
+    if (actors) {
+      const index = actors.indexOf(actor);
+      if (index !== -1) {
+        actors.splice(index, 1);
+      }
+      if (actors.length === 0) {
+        this.#actorsByName.delete(actor.name);
+      }
+    }
+  }
+
+  getActor(
+    name: string
+  ): Actor<TContext> | null {
+    const actors = this.#actorsByName.get(name);
+    if (!actors) {
+      return null;
+    }
+
+    for (const actor of actors) {
+      if (!actor.pendingForDestruction) {
+        return actor;
+      }
+    }
+
+    return null;
+  }
+
   destroyComponent(
-    component: ActorComponent<any>
+    component: ActorComponent<TContext>
   ) {
     if (component.pendingForDestruction) {
       return;

packages/engine/src/systems/World.ts

@@ -11,7 +11,7 @@ import {
   type ActorOptions
 } from "../actor/index.ts";
 import {
-  type SceneContract
+  type SceneManager
 } from "./SceneManager.ts";
 import { Input } from "../controls/Input.class.ts";
 import { GlobalAudio } from "../audio/GlobalAudio.ts";
@@ -33,7 +33,7 @@ export interface WorldOptions<
 > {
   enableOnExit?: boolean;
 
-  sceneManager: SceneContract;
+  sceneManager: SceneManager<TContext>;
   input?: Input;
   audio?: GlobalAudio;
   context?: TContext;
@@ -52,7 +52,7 @@ export class World<
   renderer: Renderer<T>;
   input: Input;
   loadingManager: THREE.LoadingManager = new THREE.LoadingManager();
-  sceneManager: SceneContract;
+  sceneManager: SceneManager<TContext>;
   audio: GlobalAudio;
   context: TContext;
   loop: FixedTimeStep;

packages/engine/src/systems/rendering/ThreeRenderer.ts

@@ -10,7 +10,8 @@ import type {
   RenderComponent,
   RendererEvents
 } from "./Renderer.ts";
-import type { SceneContract } from "../SceneManager.ts";
+import type { WorldDefaultContext } from "../World.ts";
+import type { SceneManager } from "../SceneManager.ts";
 import {
   type RenderMode,
   type RenderStrategy,
@@ -20,22 +21,24 @@ import {
 
 export type ThreeRendererEvents = RendererEvents;
 
-export interface ThreeRendererOptions {
+export interface ThreeRendererOptions<
+  TContext = WorldDefaultContext
+> {
   /**
    * @default "direct"
    */
   renderMode: RenderMode;
-  sceneManager: SceneContract;
+  sceneManager: SceneManager<TContext>;
 }
 
-export class ThreeRenderer extends EventEmitter<
-  ThreeRendererEvents
-> implements Renderer {
+export class ThreeRenderer<
+  TContext = WorldDefaultContext
+> extends EventEmitter<ThreeRendererEvents> implements Renderer {
   webGLRenderer: THREE.WebGLRenderer;
   renderComponents: RenderComponent[] = [];
   renderStrategy: RenderStrategy;
   ratio: number | null = null;
-  sceneManager: SceneContract;
+  sceneManager: SceneManager<TContext>;
 
   #resizeObserver: ResizeObserver | null = null;
   #pendingResizeWidth = 0;
@@ -44,7 +47,7 @@ export class ThreeRenderer extends EventEmitter<
 
   constructor(
     canvas: HTMLCanvasElement,
-    options: ThreeRendererOptions
+    options: ThreeRendererOptions<TContext>
   ) {
     super();
     const { sceneManager, renderMode = "direct" } = options;

packages/engine/test/mocks.ts

@@ -29,12 +29,16 @@ export function createWorld(): {
   sceneManager: {
     componentsToBeStarted: ActorComponent[];
     tree: ReturnType<typeof createTreeActor>;
+    registerActor: ReturnType<typeof mock.fn>;
+    unregisterActor: ReturnType<typeof mock.fn>;
   };
 } {
   return {
     sceneManager: {
       componentsToBeStarted: [],
-      tree: createTreeActor()
+      tree: createTreeActor(),
+      registerActor: mock.fn(),
+      unregisterActor: mock.fn()
     }
   };
 }