@gg-web-engine/core 0.0.57 → 0.0.59

package/dist/base/components/rendering/i-renderer.component.d.ts

@@ -1,7 +1,7 @@
 import { Point2 } from '../../models/points';
 import { Observable } from 'rxjs';
 import { IWorldComponent } from '../i-world-component';
-import { GgWorld, VisualTypeDocRepo } from '../../gg-world';
+import { GgWorld, GgWorldTypeDocVPatch, VisualTypeDocRepo } from '../../gg-world';
 import { IEntity } from '../../entities/i-entity';
 import { IVisualSceneComponent } from './i-visual-scene.component';
 /**
@@ -20,10 +20,11 @@ export type RendererOptions = {
     forceResolution?: number;
     antialias: boolean;
 };
-export declare abstract class IRendererComponent<D, R, VTypeDoc extends VisualTypeDocRepo<D, R> = VisualTypeDocRepo<D, R>> implements IWorldComponent<D, R, VTypeDoc> {
+export declare abstract class IRendererComponent<D, R, VTypeDoc extends VisualTypeDocRepo<D, R> = VisualTypeDocRepo<D, R>> implements IWorldComponent<D, R, GgWorldTypeDocVPatch<D, R, VTypeDoc>> {
     readonly scene: IVisualSceneComponent<D, R, VTypeDoc>;
     readonly canvas?: HTMLCanvasElement | undefined;
     entity: IEntity | null;
+    abstract camera: VTypeDoc['camera'];
     /** Specifies the options for the renderer. */
     readonly rendererOptions: RendererOptions & Partial<VTypeDoc['rendererExtraOpts']>;
     /** get flag whether renderer shows physics debugger view */
@@ -35,8 +36,8 @@ export declare abstract class IRendererComponent<D, R, VTypeDoc extends VisualTy
      * Renders the scene.
      */
     abstract render(): void;
-    abstract addToWorld(world: GgWorld<D, R, VTypeDoc>): void;
-    abstract removeFromWorld(world: GgWorld<D, R, VTypeDoc>): void;
+    abstract addToWorld(world: GgWorld<D, R, GgWorldTypeDocVPatch<D, R, VTypeDoc>>): void;
+    abstract removeFromWorld(world: GgWorld<D, R, GgWorldTypeDocVPatch<D, R, VTypeDoc>>): void;
     /**
      * Resizes the renderer to the specified size.
      * @param {Point2} newSize - The new size of the renderer.

package/dist/base/components/rendering/i-visual-scene.component.d.ts

@@ -1,6 +1,8 @@
 import { IComponent } from '../i-component';
 import { VisualTypeDocRepo } from '../../gg-world';
-export interface IVisualSceneComponent<D, R, TypeDoc extends VisualTypeDocRepo<D, R> = VisualTypeDocRepo<D, R>> extends IComponent {
-    readonly factory: TypeDoc['factory'];
+import { RendererOptions } from './i-renderer.component';
+export interface IVisualSceneComponent<D, R, VTypeDoc extends VisualTypeDocRepo<D, R> = VisualTypeDocRepo<D, R>> extends IComponent {
+    readonly factory: VTypeDoc['factory'];
     init(): Promise<void>;
+    createRenderer(camera: VTypeDoc['camera'], canvas?: HTMLCanvasElement, rendererOptions?: Partial<RendererOptions & VTypeDoc['rendererExtraOpts']>): VTypeDoc['renderer'];
 }

package/dist/base/entities/controllers/animation-mixer.d.ts

@@ -1,6 +1,6 @@
 import { IEntity } from '../i-entity';
 import { Observable, Subject } from 'rxjs';
-import { GgWorld, PhysicsTypeDocRepo, VisualTypeDocRepo } from '../../gg-world';
+import { GgWorld, GgWorldTypeDocRepo } from '../../gg-world';
 export type AnimationFunction<T> = (elapsed: number, delta: number) => T;
 /**
  * A class that performs property animations for a specific type `T` by using provided animation function.
@@ -8,7 +8,7 @@ export type AnimationFunction<T> = (elapsed: number, delta: number) => T;
  * The current value of the animation can be subscribed to using the `subscribeToValue` property.
  * The animation function can be changed with `transitAnimationFunction` or `transitFromStaticState`.
  */
-export declare class AnimationMixer<T, D = any, R = any, VTypeDoc extends VisualTypeDocRepo<D, R> = VisualTypeDocRepo<D, R>, PTypeDoc extends PhysicsTypeDocRepo<D, R> = PhysicsTypeDocRepo<D, R>> extends IEntity<D, R, VTypeDoc, PTypeDoc> {
+export declare class AnimationMixer<T, D = any, R = any, TypeDoc extends GgWorldTypeDocRepo<D, R> = GgWorldTypeDocRepo<D, R>> extends IEntity<D, R, TypeDoc> {
     protected _animationFunction: AnimationFunction<T>;
     protected _lerp: (a: T, b: T, t: number) => T;
     readonly tickOrder: number;
@@ -71,6 +71,6 @@ export declare class AnimationMixer<T, D = any, R = any, VTypeDoc extends Visual
      * @param easing an easing function for transition
      */
     transitAnimationFunction(newFunc: AnimationFunction<T>, transitionDuration: number, easing?: (t: number) => number): void;
-    onSpawned(world: GgWorld<D, R, VTypeDoc, PTypeDoc>): void;
+    onSpawned(world: GgWorld<D, R, TypeDoc>): void;
     dispose(): void;
 }

package/dist/base/entities/group.entity.d.ts

@@ -0,0 +1,17 @@
+import { GgWorldTypeDocRepo } from '../gg-world';
+import { IEntity, TickOrder } from './i-entity';
+/**
+ * A trivial entity with no rendering/physics of its own: it exists purely as a parent/grouping
+ * node. `LevelLoader.loadLevel`/`loadLevelFromUrl` hand one back for every loaded level - every
+ * entity the level's JSON produced is added as one of its children (see `IEntity.addChildren`),
+ * so the whole level can be torn down in a single call:
+ * `world.removeEntity(level, true)` cascades removal + disposal to every child
+ * (see `IEntity.onRemoved`/`dispose`). Also used internally to group the several entities a single
+ * multi-piece GLB load can produce under one name (see the built-in `"Glb"` level entity class).
+ * @template D - The position type
+ * @template R - The rotation type
+ * @template TypeDoc - The type document repository
+ */
+export declare class GroupEntity<D = any, R = any, TypeDoc extends GgWorldTypeDocRepo<D, R> = GgWorldTypeDocRepo<D, R>> extends IEntity<D, R, TypeDoc> {
+    readonly tickOrder = TickOrder.OBJECTS_BINDING;
+}

package/dist/base/entities/group.entity.js

@@ -0,0 +1,19 @@
+import { IEntity, TickOrder } from './i-entity';
+/**
+ * A trivial entity with no rendering/physics of its own: it exists purely as a parent/grouping
+ * node. `LevelLoader.loadLevel`/`loadLevelFromUrl` hand one back for every loaded level - every
+ * entity the level's JSON produced is added as one of its children (see `IEntity.addChildren`),
+ * so the whole level can be torn down in a single call:
+ * `world.removeEntity(level, true)` cascades removal + disposal to every child
+ * (see `IEntity.onRemoved`/`dispose`). Also used internally to group the several entities a single
+ * multi-piece GLB load can produce under one name (see the built-in `"Glb"` level entity class).
+ * @template D - The position type
+ * @template R - The rotation type
+ * @template TypeDoc - The type document repository
+ */
+export class GroupEntity extends IEntity {
+    constructor() {
+        super(...arguments);
+        this.tickOrder = TickOrder.OBJECTS_BINDING;
+    }
+}

package/dist/base/entities/i-entity.d.ts

@@ -1,4 +1,4 @@
-import { GgWorld, PhysicsTypeDocRepo, VisualTypeDocRepo } from '../gg-world';
+import { GgWorld, GgWorldTypeDocRepo } from '../gg-world';
 import { Observable, Subject } from 'rxjs';
 import { IWorldComponent } from '../components/i-world-component';
 /**
@@ -13,7 +13,7 @@ export declare enum TickOrder {
     RENDERING = 1000,
     POST_RENDERING = 1200
 }
-export declare abstract class IEntity<D = any, R = any, VTypeDoc extends VisualTypeDocRepo<D, R> = VisualTypeDocRepo<D, R>, PTypeDoc extends PhysicsTypeDocRepo<D, R> = PhysicsTypeDocRepo<D, R>> {
+export declare abstract class IEntity<D = any, R = any, TypeDoc extends GgWorldTypeDocRepo<D, R> = GgWorldTypeDocRepo<D, R>> {
     private static default_name_counter;
     /**
      * will receive [elapsed time, delta] of each world clock tick
@@ -26,8 +26,8 @@ export declare abstract class IEntity<D = any, R = any, VTypeDoc extends VisualT
     /**
      * a world reference, where this entity was added to
      */
-    protected _world: GgWorld<D, R, VTypeDoc, PTypeDoc> | null;
-    get world(): GgWorld<D, R, VTypeDoc, PTypeDoc> | null;
+    protected _world: GgWorld<D, R, TypeDoc> | null;
+    get world(): GgWorld<D, R, TypeDoc> | null;
     protected _name: string;
     get name(): string;
     set name(value: string);
@@ -42,15 +42,26 @@ export declare abstract class IEntity<D = any, R = any, VTypeDoc extends VisualT
     get children(): IEntity[];
     addChildren(...entities: IEntity[]): void;
     removeChildren(entities: IEntity[], dispose?: boolean): void;
+    /**
+     * Find a descendant entity by name, searching this entity's own children and their children
+     * recursively (depth-first) - not the whole world, just this entity's subtree. Useful e.g. to
+     * pull a specific entity back out of a `GroupEntity` a `LevelLoader` handed back:
+     * `level.getChildEntityByName('KillFloor')`.
+     * @param name - The descendant entity's `name`
+     * @returns The matching descendant
+     * @throws if no descendant has that name
+     */
+    getChildEntityByName<T extends IEntity = IEntity>(name: string): T;
+    private findChildEntityByName;
     private _components;
-    get components(): IWorldComponent<D, R, VTypeDoc, PTypeDoc>[];
-    addComponents(...components: IWorldComponent<D, R, VTypeDoc, PTypeDoc>[]): void;
-    removeComponents(components: IWorldComponent<D, R, VTypeDoc, PTypeDoc>[], dispose?: boolean): void;
+    get components(): IWorldComponent<D, R, TypeDoc>[];
+    addComponents(...components: IWorldComponent<D, R, TypeDoc>[]): void;
+    removeComponents(components: IWorldComponent<D, R, TypeDoc>[], dispose?: boolean): void;
     protected _onSpawned$: Subject<void>;
     protected _onRemoved$: Subject<void>;
     get onSpawned$(): Observable<void>;
     get onRemoved$(): Observable<void>;
-    onSpawned(world: GgWorld<D, R, VTypeDoc, PTypeDoc>): void;
+    onSpawned(world: GgWorld<D, R, TypeDoc>): void;
     onRemoved(): void;
     dispose(): void;
 }

package/dist/base/entities/i-entity.js

@@ -74,6 +74,34 @@ export class IEntity {
             }
         }
     }
+    /**
+     * Find a descendant entity by name, searching this entity's own children and their children
+     * recursively (depth-first) - not the whole world, just this entity's subtree. Useful e.g. to
+     * pull a specific entity back out of a `GroupEntity` a `LevelLoader` handed back:
+     * `level.getChildEntityByName('KillFloor')`.
+     * @param name - The descendant entity's `name`
+     * @returns The matching descendant
+     * @throws if no descendant has that name
+     */
+    getChildEntityByName(name) {
+        const found = this.findChildEntityByName(name);
+        if (!found) {
+            throw new Error(`No child entity named "${name}" found under "${this.name}"`);
+        }
+        return found;
+    }
+    findChildEntityByName(name) {
+        for (const child of this._children) {
+            if (child.name === name) {
+                return child;
+            }
+            const found = child.findChildEntityByName(name);
+            if (found) {
+                return found;
+            }
+        }
+        return undefined;
+    }
     get components() {
         return [...this._components];
     }

package/dist/base/entities/i-renderable.entity.d.ts

@@ -1,6 +1,6 @@
 import { IEntity } from './i-entity';
-import { PhysicsTypeDocRepo, VisualTypeDocRepo } from '../gg-world';
-export declare abstract class IRenderableEntity<D = any, R = any, TypeDoc extends VisualTypeDocRepo<D, R> = VisualTypeDocRepo<D, R>, PTypeDoc extends PhysicsTypeDocRepo<D, R> = PhysicsTypeDocRepo<D, R>> extends IEntity<D, R, TypeDoc, PTypeDoc> {
+import { GgWorldTypeDocRepo } from '../gg-world';
+export declare abstract class IRenderableEntity<D = any, R = any, TypeDoc extends GgWorldTypeDocRepo<D, R> = GgWorldTypeDocRepo<D, R>> extends IEntity<D, R, TypeDoc> {
     private _visible;
     get visible(): boolean;
     get worldVisible(): boolean;

package/dist/base/entities/i-renderer.entity.d.ts

@@ -1,14 +1,15 @@
 import { IEntity, TickOrder } from './i-entity';
-import { GgWorld, VisualTypeDocRepo } from '../gg-world';
+import { GgWorld, GgWorldTypeDocVPatch, VisualTypeDocRepo } from '../gg-world';
 import { BehaviorSubject, Observable } from 'rxjs';
 import { Point2 } from '../models/points';
 import { RendererOptions } from '../components/rendering/i-renderer.component';
+import { IPositionable } from '../interfaces/i-positionable';
 /**
  * Represents a base class for a renderer entity.
  * @class
  */
-export declare abstract class IRendererEntity<D, R, TypeDoc extends VisualTypeDocRepo<D, R> = VisualTypeDocRepo<D, R>> extends IEntity<D, R, TypeDoc> {
-    readonly renderer: TypeDoc['renderer'];
+export declare abstract class IRendererEntity<D, R, VTypeDoc extends VisualTypeDocRepo<D, R> = VisualTypeDocRepo<D, R>> extends IEntity<D, R, GgWorldTypeDocVPatch<D, R, VTypeDoc>> implements IPositionable<D, R> {
+    readonly renderer: VTypeDoc['renderer'];
     readonly tickOrder = TickOrder.RENDERING;
     /** Represents the current size of the renderer. */
     protected _rendererSize$: BehaviorSubject<Point2 | null>;
@@ -23,6 +24,11 @@ export declare abstract class IRendererEntity<D, R, TypeDoc extends VisualTypeDo
      */
     get rendererSize(): Point2 | null;
     get rendererOptions(): RendererOptions;
+    get camera(): VTypeDoc['camera'];
+    get position(): D;
+    set position(value: D);
+    get rotation(): R;
+    set rotation(value: R);
     /** get flag whether renderer shows physics debugger view */
     get physicsDebugViewActive(): boolean;
     /** turns on/off physics debugger view for this renderer */
@@ -31,7 +37,7 @@ export declare abstract class IRendererEntity<D, R, TypeDoc extends VisualTypeDo
      Initializes a new instance of the BaseGgRenderer class.
      * @param renderer
      */
-    constructor(renderer: TypeDoc['renderer']);
-    onSpawned(world: GgWorld<D, R, TypeDoc>): void;
+    constructor(renderer: VTypeDoc['renderer']);
+    onSpawned(world: GgWorld<D, R, GgWorldTypeDocVPatch<D, R, VTypeDoc>>): void;
     dispose(): void;
 }

package/dist/base/entities/i-renderer.entity.js

@@ -23,6 +23,21 @@ export class IRendererEntity extends IEntity {
     get rendererOptions() {
         return this.renderer.rendererOptions;
     }
+    get camera() {
+        return this.renderer.camera;
+    }
+    get position() {
+        return this.camera.position;
+    }
+    set position(value) {
+        this.renderer.camera.position = value;
+    }
+    get rotation() {
+        return this.renderer.camera.rotation;
+    }
+    set rotation(value) {
+        this.renderer.camera.rotation = value;
+    }
     /** get flag whether renderer shows physics debugger view */
     get physicsDebugViewActive() {
         return this.renderer.physicsDebugViewActive;

package/dist/base/gg-world.d.ts

@@ -1,23 +1,47 @@
 import { IDisplayObjectComponent, IEntity, IPhysicsWorldComponent, IPositionable, IRenderableEntity, IRendererComponent, IRendererEntity, IRigidBodyComponent, ITriggerComponent, IVisualSceneComponent, KeyboardInput, PausableClock } from '../base';
 import { Subject } from 'rxjs';
+import { IVisualScene2dComponent, VisualTypeDocRepo2D } from '../2d';
 export type VisualTypeDocRepo<D, R> = {
     factory: unknown;
     displayObject: IDisplayObjectComponent<D, R>;
     renderer: IRendererComponent<D, R>;
     rendererExtraOpts: {};
+    camera: IPositionable<D, R>;
 };
 export type PhysicsTypeDocRepo<D, R> = {
     factory: unknown;
     rigidBody: IRigidBodyComponent<D, R>;
     trigger: ITriggerComponent<D, R>;
 };
-export declare abstract class GgWorld<D, R, VTypeDoc extends VisualTypeDocRepo<D, R> = VisualTypeDocRepo<D, R>, PTypeDoc extends PhysicsTypeDocRepo<D, R> = PhysicsTypeDocRepo<D, R>, VS extends IVisualSceneComponent<D, R, VTypeDoc> = IVisualSceneComponent<D, R, VTypeDoc>, PW extends IPhysicsWorldComponent<D, R, PTypeDoc> = IPhysicsWorldComponent<D, R, PTypeDoc>> {
-    readonly visualScene: VS;
-    readonly physicsWorld: PW;
+export type GgWorldTypeDocRepo<D, R> = {
+    vTypeDoc: VisualTypeDocRepo<D, R>;
+    pTypeDoc: PhysicsTypeDocRepo<D, R>;
+};
+export type GgWorldTypeDocVPatch<D, R, VTypeDoc extends VisualTypeDocRepo<D, R>> = Omit<GgWorldTypeDocRepo<D, R>, 'vTypeDoc'> & {
+    vTypeDoc: VTypeDoc;
+};
+export type GgWorldTypeDocPPatch<D, R, PTypeDoc extends PhysicsTypeDocRepo<D, R>> = Omit<GgWorldTypeDocRepo<D, R>, 'pTypeDoc'> & {
+    pTypeDoc: PTypeDoc;
+};
+export type GgWorldSceneTypeRepo<D, R, TypeDoc extends GgWorldTypeDocRepo<D, R> = GgWorldTypeDocRepo<D, R>> = {
+    visualScene: IVisualSceneComponent<D, R, TypeDoc['vTypeDoc']> | null;
+    physicsWorld: IPhysicsWorldComponent<D, R, TypeDoc['pTypeDoc']> | null;
+};
+export type GgWorldSceneTypeDocVPatch<D, R, VTypeDoc extends VisualTypeDocRepo2D, VS extends IVisualScene2dComponent<VTypeDoc> | null> = Omit<GgWorldSceneTypeRepo<D, R>, 'visualScene'> & {
+    visualScene: VS;
+};
+export type GgWorldSceneTypeDocPPatch<D, R, PTypeDoc extends PhysicsTypeDocRepo<D, R>, PW extends IPhysicsWorldComponent<D, R, PTypeDoc> | null> = Omit<GgWorldSceneTypeRepo<D, R>, 'physicsWorld'> & {
+    physicsWorld: PW;
+};
+export type TypeDocOf<W extends GgWorld<any, any>> = W extends GgWorld<infer D, infer R, infer TypeDoc> ? TypeDoc : never;
+export type SceneTypeDocOf<W extends GgWorld<any, any>> = W extends GgWorld<infer D, infer R, infer TypeDoc, infer SceneTypeDoc> ? SceneTypeDoc : never;
+export declare abstract class GgWorld<D, R, TypeDoc extends GgWorldTypeDocRepo<D, R> = GgWorldTypeDocRepo<D, R>, SceneTypeDoc extends GgWorldSceneTypeRepo<D, R, TypeDoc> = GgWorldSceneTypeRepo<D, R, TypeDoc>> {
     private static default_name_counter;
     private static _documentWorlds;
     static readonly worldCreated$: Subject<GgWorld<any, any>>;
     static get documentWorlds(): GgWorld<any, any>[];
+    readonly visualScene: SceneTypeDoc['visualScene'];
+    readonly physicsWorld: SceneTypeDoc['physicsWorld'];
     readonly worldClock: PausableClock;
     readonly keyboardInput: KeyboardInput;
     name: string;
@@ -29,7 +53,10 @@ export declare abstract class GgWorld<D, R, VTypeDoc extends VisualTypeDocRepo<D
     readonly tickForwardedTo$: Subject<IEntity | 'PHYSICS_WORLD'>;
     readonly paused$: Subject<boolean>;
     readonly disposed$: Subject<void>;
-    protected constructor(visualScene: VS, physicsWorld: PW);
+    protected constructor(args: {
+        visualScene?: SceneTypeDoc['visualScene'];
+        physicsWorld?: SceneTypeDoc['physicsWorld'];
+    });
     init(): Promise<void>;
     start(): void;
     pauseWorld(): void;
@@ -40,9 +67,19 @@ export declare abstract class GgWorld<D, R, VTypeDoc extends VisualTypeDocRepo<D
     createClock(autoStart: boolean): PausableClock;
     dispose(): void;
     abstract addPrimitiveRigidBody(descr: unknown, // type defined in subclasses
-    position?: D, rotation?: R, material?: unknown): IPositionable<D, R> & IRenderableEntity<D, R, VTypeDoc>;
+    position?: D, rotation?: R, material?: unknown): IPositionable<D, R> & IRenderableEntity<D, R, TypeDoc>;
     addEntity(entity: IEntity): void;
     removeEntity(entity: IEntity, dispose?: boolean): void;
+    /**
+     * Find an entity anywhere in the world by name. `children` is a flat list of every entity ever
+     * added via `addEntity` (nested entities included - `addChildren`/`onSpawned` cascade into it
+     * too), so this is a plain linear scan, not a tree walk; to search inside one particular
+     * entity's own subtree instead, use `IEntity.getChildEntityByName`.
+     * @param name - The entity's `name`
+     * @returns The first entity found with that name (insertion order), if more than one shares it
+     * @throws if no entity in the world has that name
+     */
+    getEntityByName<T extends IEntity = IEntity>(name: string): T;
     private onGgStaticInitialized;
     protected registerConsoleCommands(ggstatic: {
         registerConsoleCommand: (world: GgWorld<any, any> | null, command: string, handler: (...args: string[]) => Promise<string>, doc?: string) => void;

package/dist/base/gg-world.js

@@ -17,9 +17,7 @@ export class GgWorld {
     get renderers() {
         return this.tickListeners.filter(e => e instanceof IRendererEntity);
     }
-    constructor(visualScene, physicsWorld) {
-        this.visualScene = visualScene;
-        this.physicsWorld = physicsWorld;
+    constructor(args) {
         this.worldClock = new PausableClock(false);
         this.keyboardInput = new KeyboardInput();
         this.name = 'w0x' + (GgWorld.default_name_counter++).toString(16);
@@ -32,6 +30,8 @@ export class GgWorld {
         this.tickForwardedTo$ = new Subject();
         this.paused$ = new Subject();
         this.disposed$ = new Subject();
+        this.visualScene = args.visualScene || null;
+        this.physicsWorld = args.physicsWorld || null;
         this.keyboardInput.start();
         if (window.ggstatic) {
             this.registerConsoleCommands(window.ggstatic);
@@ -46,7 +46,14 @@ export class GgWorld {
     }
     init() {
         return __awaiter(this, void 0, void 0, function* () {
-            yield Promise.all([this.physicsWorld.init(), this.visualScene.init()]);
+            const initPromises = [];
+            if (this.visualScene) {
+                initPromises.push(this.visualScene.init());
+            }
+            if (this.physicsWorld) {
+                initPromises.push(this.physicsWorld.init());
+            }
+            yield Promise.all(initPromises);
             const forwardTick = (listener, elapsed, delta) => {
                 if (listener.active) {
                     this.tickForwardTo$.next(listener);
@@ -65,9 +72,11 @@ export class GgWorld {
                     forwardTick(this.tickListeners[i], elapsed, delta);
                 }
                 // run physics simulation
-                this.tickForwardTo$.next('PHYSICS_WORLD');
-                this.physicsWorld.simulate(delta);
-                this.tickForwardedTo$.next('PHYSICS_WORLD');
+                if (this.physicsWorld) {
+                    this.tickForwardTo$.next('PHYSICS_WORLD');
+                    this.physicsWorld.simulate(delta);
+                    this.tickForwardedTo$.next('PHYSICS_WORLD');
+                }
                 // emit tick to all remained entities
                 for (i; i < this.tickListeners.length; i++) {
                     forwardTick(this.tickListeners[i], elapsed, delta);
@@ -114,14 +123,24 @@ export class GgWorld {
         }
         this.children.splice(0, this.children.length);
         this.tickListeners.splice(0, this.tickListeners.length);
-        this.physicsWorld.dispose();
-        this.visualScene.dispose();
+        if (this.physicsWorld) {
+            this.physicsWorld.dispose();
+        }
+        if (this.visualScene) {
+            this.visualScene.dispose();
+        }
         GgWorld._documentWorlds.splice(GgWorld._documentWorlds.indexOf(this), 1);
         this.disposed$.next();
         this.disposed$.complete();
     }
     addEntity(entity) {
-        if (!!entity.world) {
+        if (entity.world === this) {
+            // Already a member of this world - e.g. reparented (via addChildren) after having been
+            // added directly, as level-loaded entities are. Not an error: just a no-op, since
+            // addChildren already updated the parent/children bookkeeping before calling back in here.
+            return;
+        }
+        if (entity.world) {
             console.warn('Trying to spawn entity, which is already spawned');
             return;
         }
@@ -143,6 +162,22 @@ export class GgWorld {
             entity.dispose();
         }
     }
+    /**
+     * Find an entity anywhere in the world by name. `children` is a flat list of every entity ever
+     * added via `addEntity` (nested entities included - `addChildren`/`onSpawned` cascade into it
+     * too), so this is a plain linear scan, not a tree walk; to search inside one particular
+     * entity's own subtree instead, use `IEntity.getChildEntityByName`.
+     * @param name - The entity's `name`
+     * @returns The first entity found with that name (insertion order), if more than one shares it
+     * @throws if no entity in the world has that name
+     */
+    getEntityByName(name) {
+        const found = this.children.find(e => e.name === name);
+        if (!found) {
+            throw new Error(`No entity named "${name}" found in the world`);
+        }
+        return found;
+    }
     onGgStaticInitialized() {
         window.removeEventListener('ggstatic_added', this.onGgStaticInitialized);
         this.registerConsoleCommands(window.ggstatic);

package/dist/base/index.d.ts

@@ -1,3 +1,6 @@
+export * from './blueprint/blueprint';
+export * from './blueprint/blueprint-node';
+export * from './blueprint/nodes/remove-entity.node';
 export * from './clock/global-clock';
 export * from './clock/i-clock';
 export * from './clock/pausable-clock';
@@ -14,6 +17,7 @@ export * from './data-structures/bitmask';
 export * from './data-structures/graph';
 export * from './entities/controllers/animation-mixer';
 export * from './entities/controllers/inline-controller';
+export * from './entities/group.entity';
 export * from './entities/i-entity';
 export * from './entities/i-renderer.entity';
 export * from './entities/i-renderable.entity';
@@ -26,6 +30,7 @@ export * from './models/axis-directions';
 export * from './models/body-options';
 export * from './models/geometry-nodes';
 export * from './models/points';
+export * from './models/raycasting';
 export * from './math/box';
 export * from './math/point2';
 export * from './math/point3';
@@ -35,3 +40,4 @@ export * from './math/matrix4';
 export * from './math/splines';
 export * from './pipes/gg-elastic.pipe';
 export * from './gg-world';
+export * from './level-loader';

package/dist/base/index.js

@@ -1,3 +1,6 @@
+export * from './blueprint/blueprint';
+export * from './blueprint/blueprint-node';
+export * from './blueprint/nodes/remove-entity.node';
 export * from './clock/global-clock';
 export * from './clock/i-clock';
 export * from './clock/pausable-clock';
@@ -14,6 +17,7 @@ export * from './data-structures/bitmask';
 export * from './data-structures/graph';
 export * from './entities/controllers/animation-mixer';
 export * from './entities/controllers/inline-controller';
+export * from './entities/group.entity';
 export * from './entities/i-entity';
 export * from './entities/i-renderer.entity';
 export * from './entities/i-renderable.entity';
@@ -26,6 +30,7 @@ export * from './models/axis-directions';
 export * from './models/body-options';
 export * from './models/geometry-nodes';
 export * from './models/points';
+export * from './models/raycasting';
 export * from './math/box';
 export * from './math/point2';
 export * from './math/point3';
@@ -35,3 +40,4 @@ export * from './math/matrix4';
 export * from './math/splines';
 export * from './pipes/gg-elastic.pipe';
 export * from './gg-world';
+export * from './level-loader';

package/dist/base/inputs/mouse.input.js

@@ -10,6 +10,7 @@ const DEFAULT_MOUSE_INPUT_OPTIONS = {
  */
 export var MouseInputState;
 (function (MouseInputState) {
+    //MouseInputState {
     /**
      No mouse or touch input is detected. Mouse move can still be emitted
      */