@gg-web-engine/core 0.0.48 → 0.0.56

package/dist/3d/entities/controllers/input/orbit-camera.controller.js

@@ -7,72 +7,103 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-import { IEntity, MouseInput, MouseInputState, Pnt3, Qtrn, TickOrder, } from '../../../../base';
-import { filter, takeUntil } from 'rxjs';
+import { ggElastic, IEntity, MouseInput, MouseInputState, Pnt2, Pnt3, Qtrn, TickOrder, } from '../../../../base';
+import { BehaviorSubject, filter, Subject, takeUntil } from 'rxjs';
 import { map } from 'rxjs/operators';
 const DEFAULT_OPTIONS = {
     mouseOptions: {},
-    orbiting: { sensitivityX: 1, sensitivityY: 1 }, // sensitivity units: rotation degree per 5 pixels movement
+    orbiting: { sensitivityX: 1, sensitivityY: 1 },
+    orbitingElasticity: 0,
     zooming: { sensitivity: 1 },
     panning: { sensitivityX: 1, sensitivityY: 1 },
     dollying: { sensitivity: 1 },
 };
 export class OrbitCameraController extends IEntity {
-    get radius() {
-        return this.spherical.radius;
+    get active() {
+        return super.active;
     }
-    set radius(value) {
-        this.spherical.radius = value;
+    set active(value) {
+        if (!super.active && value) {
+            this.reset();
+        }
+        super.active = value;
     }
-    get phi() {
-        return this.spherical.phi;
+    get spherical() {
+        return this._spherical;
     }
-    set phi(value) {
-        this.spherical.phi = Math.max(0.000001, Math.min(Math.PI - 0.000001, value));
-    }
-    get theta() {
-        return this.spherical.theta;
-    }
-    set theta(value) {
-        this.spherical.theta = value;
+    set spherical(value) {
+        this._spherical.phi = Math.max(0.000001, Math.min(Math.PI - 0.000001, value.phi));
+        this._spherical.theta = value.theta;
+        this._spherical.radius = value.radius;
+        this.resetMotion$.next();
     }
     constructor(camera, options = {}) {
         super();
         this.camera = camera;
         this.tickOrder = TickOrder.INPUT_CONTROLLERS;
-        this.spherical = { phi: 0, radius: 10, theta: 0 };
+        this._spherical = { phi: 0, radius: 10, theta: 0 };
         this.target = Pnt3.O;
+        this.resetMotion$ = new Subject();
         this.options = Object.assign(Object.assign({}, DEFAULT_OPTIONS), options);
         this.mouseInput = new MouseInput(this.options.mouseOptions);
     }
+    reset() {
+        let targetDistance = Pnt3.dist(this.target, this.camera.position);
+        this.target = Pnt3.add(this.camera.position, Pnt3.rot({ x: 0, y: 0, z: -targetDistance }, this.camera.rotation));
+        this._spherical = Pnt3.toSpherical(Pnt3.sub(this.camera.position, this.target));
+        this.resetMotion$.next();
+    }
     onSpawned(world) {
         const _super = Object.create(null, {
             onSpawned: { get: () => super.onSpawned }
         });
         return __awaiter(this, void 0, void 0, function* () {
             yield _super.onSpawned.call(this, world);
-            this.spherical = Pnt3.toSpherical(Pnt3.sub(this.camera.position, this.target));
+            this._spherical = Pnt3.toSpherical(Pnt3.sub(this.camera.position, this.target));
             if (this.options.orbiting) {
-                this.mouseInput.delta$
-                    .pipe(takeUntil(this._onRemoved$), filter(() => this.mouseInput.state == MouseInputState.DRAG))
-                    .subscribe(delta => {
-                    this.spherical.theta -= (delta.x * this.options.orbiting.sensitivityX * Math.PI) / 900;
-                    this.spherical.phi -= (delta.y * this.options.orbiting.sensitivityY * Math.PI) / 900;
-                    this.spherical.phi = Math.max(0.000001, Math.min(Math.PI - 0.000001, this.spherical.phi));
-                });
+                let mouseDelta$ = this.mouseInput.delta$.pipe(takeUntil(this._onRemoved$), filter(() => this.active && this.mouseInput.state == MouseInputState.DRAG));
+                if (this.options.orbitingElasticity > 0) {
+                    const s$ = new BehaviorSubject(this._spherical);
+                    mouseDelta$.subscribe(delta => {
+                        const s = s$.getValue();
+                        s$.next({
+                            phi: Math.max(0.000001, Math.min(Math.PI - 0.000001, s.phi - (delta.y * this.options.orbiting.sensitivityY) / 1000)),
+                            theta: s.theta - (delta.x * this.options.orbiting.sensitivityX) / 1000,
+                            radius: 1,
+                        });
+                    });
+                    const startElasticMotion = () => {
+                        s$.pipe(takeUntil(this._onRemoved$), ggElastic(this.tick$, this.options.orbitingElasticity, (a, b, f) => ({ phi: a.phi + f * (b.phi - a.phi), theta: a.theta + f * (b.theta - a.theta), radius: 1 }), (a, b) => Pnt2.dist({ x: a.phi, y: a.theta }, { x: b.phi, y: b.theta }) < 0.0001), takeUntil(this.resetMotion$)).subscribe(s => {
+                            this._spherical.theta = s.theta;
+                            this._spherical.phi = s.phi;
+                        });
+                    };
+                    this.resetMotion$.pipe(takeUntil(this._onRemoved$)).subscribe(() => {
+                        s$.next(this._spherical);
+                        startElasticMotion();
+                    });
+                    startElasticMotion();
+                }
+                else {
+                    mouseDelta$.subscribe(delta => {
+                        this._spherical.theta -= (delta.x * this.options.orbiting.sensitivityX) / 1000;
+                        this._spherical.phi -= (delta.y * this.options.orbiting.sensitivityY) / 1000;
+                        this._spherical.phi = Math.max(0.000001, Math.min(Math.PI - 0.000001, this._spherical.phi));
+                    });
+                }
             }
             if (this.options.zooming) {
                 this.mouseInput.wheel$.pipe(takeUntil(this._onRemoved$)).subscribe(delta => {
                     if (delta != 0) {
-                        this.spherical.radius *= Math.pow(0.95, this.options.zooming.sensitivity * (delta > 0 ? -1 : 1));
+                        this._spherical.radius *= Math.pow(0.95, this.options.zooming.sensitivity * (delta > 0 ? -1 : 1));
                     }
                 });
             }
             const performPan = (delta) => {
-                const targetCameraVector = Pnt3.fromSpherical(this.spherical);
+                const targetCameraVector = Pnt3.fromSpherical(this._spherical);
                 const viewUp = Pnt3.rotAround(targetCameraVector, {
-                    x: -Math.sin(this.spherical.theta),
-                    y: Math.cos(this.spherical.theta),
+                    x: -Math.sin(this._spherical.theta),
+                    y: Math.cos(this._spherical.theta),
                     z: 0,
                 }, Math.PI / 2);
                 const viewRight = Pnt3.rotAround(targetCameraVector, Pnt3.norm(viewUp), Math.PI / 2);
@@ -89,14 +120,14 @@ export class OrbitCameraController extends IEntity {
                 this.mouseInput.delta$
                     .pipe(takeUntil(this._onRemoved$), filter(() => this.mouseInput.state == MouseInputState.DRAG_MIDDLE_BUTTON))
                     .subscribe(delta => {
-                    this.spherical.radius *= Math.pow(0.95, (-this.options.dollying.sensitivity * delta.y) / 10);
+                    this._spherical.radius *= Math.pow(0.95, (-this.options.dollying.sensitivity * delta.y) / 10);
                 });
             }
             if (MouseInput.isTouchDevice() && (this.options.dollying || this.options.panning)) {
                 this.mouseInput.twoTouchGestureDelta$.pipe(takeUntil(this._onRemoved$)).subscribe(delta => {
                     // dolly on fingers pitch
                     if (this.options.dollying) {
-                        this.spherical.radius *= Math.pow(0.95, (this.options.dollying.sensitivity * delta.distanceDelta) / 10);
+                        this._spherical.radius *= Math.pow(0.95, (this.options.dollying.sensitivity * delta.distanceDelta) / 10);
                     }
                     // pan on fingers move
                     if (this.options.panning) {
@@ -106,7 +137,7 @@ export class OrbitCameraController extends IEntity {
             }
             // Setup updating camera position and rotation based on input
             this.camera.tick$
-                .pipe(takeUntil(this._onRemoved$), map(() => this.spherical))
+                .pipe(takeUntil(this._onRemoved$), filter(() => this.active), map(() => this._spherical))
                 .subscribe(spherical => {
                 this.camera.position = Pnt3.add(this.target, Pnt3.fromSpherical(spherical));
                 this.camera.rotation = Qtrn.lookAt(this.camera.position, this.target);

package/dist/3d/entities/entity-3d.d.ts

@@ -5,8 +5,6 @@ import { IPositionable3d } from '../interfaces/i-positionable-3d';
 import { IRenderable3dEntity } from './i-renderable-3d.entity';
 import { PhysicsTypeDocRepo3D, VisualTypeDocRepo3D } from '../gg-3d-world';
 export declare class Entity3d<VTypeDoc extends VisualTypeDocRepo3D = VisualTypeDocRepo3D, PTypeDoc extends PhysicsTypeDocRepo3D = PhysicsTypeDocRepo3D> extends IRenderable3dEntity<VTypeDoc, PTypeDoc> implements IPositionable3d {
-    readonly object3D: VTypeDoc['displayObject'] | null;
-    readonly objectBody: PTypeDoc['rigidBody'] | null;
     readonly tickOrder = TickOrder.OBJECTS_BINDING;
     private _position;
     get position(): Point3;
@@ -14,10 +12,15 @@ export declare class Entity3d<VTypeDoc extends VisualTypeDocRepo3D = VisualTypeD
     private _rotation;
     get rotation(): Point4;
     set rotation(value: Point4);
+    readonly object3D: VTypeDoc['displayObject'] | null;
+    readonly objectBody: PTypeDoc['rigidBody'] | null;
     updateVisibility(): void;
     /**
      * Synchronize physics body transform with entity (and mesh if defined)
      * */
     protected runTransformBinding(objectBody: IRigidBody3dComponent, object3D: IDisplayObject3dComponent | null): void;
-    constructor(object3D: VTypeDoc['displayObject'] | null, objectBody?: PTypeDoc['rigidBody'] | null);
+    constructor(options: {
+        object3D?: VTypeDoc['displayObject'] | null;
+        objectBody?: PTypeDoc['rigidBody'] | null;
+    });
 }

package/dist/3d/entities/entity-3d.js

@@ -44,29 +44,32 @@ export class Entity3d extends IRenderable3dEntity {
         this._position = pos;
         this._rotation = quat;
     }
-    constructor(object3D, objectBody = null) {
+    constructor(options) {
         super();
-        this.object3D = object3D;
-        this.objectBody = objectBody;
         this.tickOrder = TickOrder.OBJECTS_BINDING;
         this._position = Pnt3.O;
         this._rotation = Qtrn.O;
-        if (objectBody) {
-            this.tick$.subscribe(() => {
-                this.runTransformBinding(objectBody, object3D);
-            });
-            this.runTransformBinding(objectBody, object3D);
-            this.name = objectBody.name;
+        this.object3D = null;
+        this.objectBody = null;
+        if (options.objectBody) {
+            this.objectBody = options.objectBody;
+            this.name = this.objectBody.name;
+            this.addComponents(this.objectBody);
         }
-        else if (object3D) {
-            this._position = object3D.position;
-            this._rotation = object3D.rotation;
-            this.name = object3D.name;
+        if (options.object3D) {
+            this.object3D = options.object3D;
+            if (!options.objectBody) {
+                this._position = this.object3D.position;
+                this._rotation = this.object3D.rotation;
+                this.name = this.object3D.name;
+            }
+            this.addComponents(this.object3D);
         }
-        else {
-            throw new Error('Cannot create entity without a mesh and a body');
+        if (this.objectBody) {
+            this.tick$.subscribe(() => {
+                this.runTransformBinding(this.objectBody, this.object3D);
+            });
+            this.runTransformBinding(this.objectBody, this.object3D);
         }
-        objectBody && this.addComponents(objectBody);
-        object3D && this.addComponents(object3D);
     }
 }

package/dist/3d/entities/raycast-vehicle-3d.entity.js

@@ -56,7 +56,7 @@ export class RaycastVehicle3dEntity extends Entity3d {
     }
     /** car mesh and physics body direction has to be pointing: y front, z up*/
     constructor(carProperties, chassis3D, vehicleComponent) {
-        super(chassis3D, vehicleComponent);
+        super({ object3D: chassis3D, objectBody: vehicleComponent });
         this.carProperties = carProperties;
         this.chassis3D = chassis3D;
         this.vehicleComponent = vehicleComponent;
@@ -104,9 +104,9 @@ export class RaycastVehicle3dEntity extends Entity3d {
                 this.wheelLocalRotation.push(null);
                 continue;
             }
-            const entity = display.displayObject.clone();
+            const displayObj = display.displayObject.clone();
             if (display.autoScaleMesh) {
-                const boundingBox = Box.expandByPoint(entity.getBoundings(), Pnt3.O);
+                const boundingBox = Box.expandByPoint(displayObj.getBoundings(), Pnt3.O);
                 const scale = Object.assign({}, Pnt3.O);
                 const wheelObjectDirection = display.wheelObjectDirection || 'x';
                 for (const dir of ['x', 'y', 'z']) {
@@ -115,7 +115,7 @@ export class RaycastVehicle3dEntity extends Entity3d {
                         ? options.tyreWidth / (boundingBox.max[dir] - boundingBox.min[dir])
                         : (options.tyreRadius * 2) / (boundingBox.max[dir] - boundingBox.min[dir]);
                 }
-                entity.scale = scale;
+                displayObj.scale = scale;
             }
             const direction = display.wheelObjectDirection || 'x';
             const flip = direction.includes('-') ? options.isLeft : !options.isLeft;
@@ -134,7 +134,7 @@ export class RaycastVehicle3dEntity extends Entity3d {
                 localRotation = { x: 0, y: 0.707107 * (flip ? 1 : -1), z: 0, w: 0.707107 };
             }
             this.wheelLocalRotation.push(localRotation);
-            const wheelEntity = new Entity3d(entity);
+            const wheelEntity = new Entity3d({ object3D: displayObj });
             wheelEntity.name = this.name + '__wheel_' + (options.isFront ? 'f' : 'r') + (options.isLeft ? 'l' : 'r');
             this.wheels.push(wheelEntity);
         }

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

@@ -36,4 +36,7 @@ export declare class Gg3dWorld<VTypeDoc extends VisualTypeDocRepo3D = VisualType
     constructor(visualScene: VS, physicsWorld: PW);
     addPrimitiveRigidBody(descr: BodyShape3DDescriptor, position?: Point3, rotation?: Point4, material?: DisplayObject3dOpts<VTypeDoc['texture']>): Entity3d<VTypeDoc, PTypeDoc>;
     addRenderer(camera: VTypeDoc['camera'], canvas?: HTMLCanvasElement, rendererOptions?: Partial<RendererOptions & VTypeDoc['rendererExtraOpts']>): Renderer3dEntity<VTypeDoc>;
+    protected registerConsoleCommands(ggstatic: {
+        registerConsoleCommand: (world: GgWorld<any, any> | null, command: string, handler: (...args: string[]) => Promise<string>, doc?: string) => void;
+    }): void;
 }

package/dist/3d/gg-3d-world.js

@@ -17,21 +17,12 @@ export class Gg3dWorld extends GgWorld {
         this.visualScene = visualScene;
         this.physicsWorld = physicsWorld;
         this.loader = new Gg3dLoader(this);
-        if (window.ggstatic) {
-            window.ggstatic.registerConsoleCommand(this, 'ph_gravity', (...args) => __awaiter(this, void 0, void 0, function* () {
-                if (args.length == 1) {
-                    args = ['0', '0', '' + -+args[0]]; // mean -Z axis
-                }
-                if (args.length > 0) {
-                    this.physicsWorld.gravity = { x: +args[0], y: +args[1], z: +args[2] };
-                }
-                return JSON.stringify(this.physicsWorld.gravity);
-            }), 'args: [float] or [float float float]; change 3D world gravity vector. 1 argument means ' +
-                '{x: 0, y: 0, z: -value}, 3 arguments set the whole vector. Default value is "9.82" or "0 0 -9.82"');
-        }
     }
     addPrimitiveRigidBody(descr, position = Pnt3.O, rotation = Qtrn.O, material = {}) {
-        const entity = new Entity3d(this.visualScene.factory.createPrimitive(descr.shape, material), this.physicsWorld.factory.createRigidBody(descr));
+        const entity = new Entity3d({
+            object3D: this.visualScene.factory.createPrimitive(descr.shape, material),
+            objectBody: this.physicsWorld.factory.createRigidBody(descr),
+        });
         entity.position = position;
         entity.rotation = rotation;
         this.addEntity(entity);
@@ -42,4 +33,21 @@ export class Gg3dWorld extends GgWorld {
         this.addEntity(entity);
         return entity;
     }
+    registerConsoleCommands(ggstatic) {
+        super.registerConsoleCommands(ggstatic);
+        ggstatic.registerConsoleCommand(this, 'gravity', (...args) => __awaiter(this, void 0, void 0, function* () {
+            if (args.length == 1) {
+                args = ['0', '0', '' + -+args[0]]; // mean -Z axis
+            }
+            if (args.length > 0) {
+                if (isNaN(+args[0]) || isNaN(+args[1]) || isNaN(+args[2])) {
+                    throw new Error('Wrong arguments');
+                }
+                this.physicsWorld.gravity = { x: +args[0], y: +args[1], z: +args[2] };
+            }
+            return JSON.stringify(this.physicsWorld.gravity);
+        }), 'args: [ ?float, ?float, ?float ]; Get or set 3D world gravity vector. 1 argument sets ' +
+            'vector {x: 0, y: 0, z: -value}, 3 arguments set the whole vector.' +
+            ' Default value is "9.82" or "0 0 -9.82"');
+    }
 }

package/dist/3d/loader.js

@@ -99,7 +99,7 @@ export class Gg3dLoader {
             const loadOptions = Object.assign(Object.assign({}, defaultLoadOptions), options);
             const { resources, meta } = yield this.loadGgGlbResources(path, loadOptions.cachingStrategy);
             const result = {
-                entities: resources.map(({ object3D, body }) => new Entity3d(object3D, body)),
+                entities: resources.map(x => new Entity3d({ object3D: x.object3D, objectBody: x.body })),
                 meta,
             };
             if (loadOptions.loadProps) {

package/dist/3d/models/shapes.d.ts

@@ -1,6 +1,8 @@
 import { Point2, Point3, Point4 } from '../../base';
 import { Body3DOptions } from './body-options';
 export type Shape3DDescriptor = {
+    collisionMargin?: number;
+} & ({
     shape: 'PLANE';
 } | {
     shape: 'BOX';
@@ -30,7 +32,7 @@ export type Shape3DDescriptor = {
     shape: 'MESH';
     vertices: Point3[];
     faces: [number, number, number][];
-};
+});
 export type Shape3DMeshDescriptor = {
     shape: 'PLANE';
     dimensions?: Point2;

package/dist/base/clock/global-clock.d.ts

@@ -1,16 +1,12 @@
-import { Observable } from 'rxjs';
-import { PausableClock } from './pausable-clock';
 import { IClock } from './i-clock';
 /**
  * A singleton class, providing ability to track time, fire ticks, provide time elapsed + tick delta.
  * Starts as soon as accessed and counts time from 01/01/1970
  */
-export declare class GgGlobalClock implements IClock {
+export declare class GgGlobalClock extends IClock {
     private static _instance;
     static get instance(): GgGlobalClock;
-    private readonly _tick$;
-    get tick$(): Observable<[number, number]>;
     get elapsedTime(): number;
-    createChildClock(autoStart: boolean): PausableClock;
     private constructor();
+    dispose(): void;
 }

package/dist/base/clock/global-clock.js

@@ -1,32 +1,32 @@
-import { animationFrameScheduler, of, Subject } from 'rxjs';
-import { map, repeat, tap } from 'rxjs/operators';
-import { PausableClock } from './pausable-clock';
+import { IClock } from './i-clock';
+const now = typeof performance === 'undefined' ? () => Date.now() : () => performance.now();
 /**
  * A singleton class, providing ability to track time, fire ticks, provide time elapsed + tick delta.
  * Starts as soon as accessed and counts time from 01/01/1970
  */
-export class GgGlobalClock {
+export class GgGlobalClock extends IClock {
     static get instance() {
         if (!GgGlobalClock._instance) {
             GgGlobalClock._instance = new GgGlobalClock();
         }
         return GgGlobalClock._instance;
     }
-    get tick$() {
-        return this._tick$.pipe(map(([oldTime, newTime]) => [newTime, newTime - oldTime]));
-    }
     get elapsedTime() {
-        return (typeof performance === 'undefined' ? Date : performance).now();
-    }
-    createChildClock(autoStart) {
-        return new PausableClock(autoStart, this);
+        return now();
     }
     constructor() {
-        this._tick$ = new Subject();
+        super(null);
         let oldRelativeTime = this.elapsedTime;
-        of(undefined, animationFrameScheduler)
-            .pipe(repeat())
-            .pipe(map(() => [oldRelativeTime, this.elapsedTime]), tap(([_, cur]) => (oldRelativeTime = cur)))
-            .subscribe(this._tick$);
+        const tick = () => {
+            requestAnimationFrame(tick);
+            const prev = oldRelativeTime;
+            const cur = this.elapsedTime;
+            oldRelativeTime = cur;
+            this._tick$.next([prev, cur - prev]);
+        };
+        requestAnimationFrame(tick);
+    }
+    dispose() {
+        throw new Error('Cannot dispose global clock');
     }
 }

package/dist/base/clock/i-clock.d.ts

@@ -1,7 +1,16 @@
-import { Observable } from 'rxjs';
-import { PausableClock } from './pausable-clock';
-export interface IClock {
+import { Observable, Subject } from 'rxjs';
+export declare abstract class IClock {
+    readonly parent: IClock | null;
+    protected readonly _tick$: Subject<[number, number]>;
+    /**
+     * Observable stream of ticks, emitting an array containing the current time and the tick delta.
+     */
     get tick$(): Observable<[number, number]>;
-    get elapsedTime(): number;
-    createChildClock(autoStart: boolean): PausableClock;
+    abstract get elapsedTime(): number;
+    protected _children: IClock[];
+    get children(): IClock[];
+    protected constructor(parent: IClock | null);
+    addChild(clock: IClock): void;
+    removeChild(clock: IClock): void;
+    dispose(): void;
 }

package/dist/base/clock/i-clock.js

@@ -1 +1,43 @@
-export {};
+import { Subject } from 'rxjs';
+export class IClock {
+    /**
+     * Observable stream of ticks, emitting an array containing the current time and the tick delta.
+     */
+    get tick$() {
+        return this._tick$.asObservable();
+    }
+    get children() {
+        return [...this._children];
+    }
+    constructor(parent) {
+        this.parent = parent;
+        this._tick$ = new Subject();
+        this._children = [];
+        if (parent) {
+            parent.addChild(this);
+        }
+    }
+    addChild(clock) {
+        if (clock.parent !== this) {
+            throw new Error('Incorrect child clock');
+        }
+        if (!this._children.includes(clock)) {
+            this._children.push(clock);
+        }
+    }
+    removeChild(clock) {
+        if (clock.parent !== this) {
+            throw new Error('Incorrect child clock');
+        }
+        this._children = this._children.filter(c => c !== clock);
+    }
+    dispose() {
+        if (this.parent) {
+            this.parent.removeChild(this);
+        }
+        for (const c of this._children) {
+            c.dispose();
+        }
+        this._tick$.complete();
+    }
+}

package/dist/base/clock/pausable-clock.d.ts

@@ -1,17 +1,12 @@
-import { Observable, Subject } from 'rxjs';
+import { Subject } from 'rxjs';
 import { IClock } from './i-clock';
 /**
  * A class providing the ability to track time, fire ticks, provide time elapsed, and tick delta with the ability to suspend/resume it.
  */
-export declare class PausableClock implements IClock {
+export declare class PausableClock extends IClock {
     protected readonly parentClock: IClock;
     private tickSub;
     private readonly _internalTick$;
-    private readonly _tick$;
-    /**
-     * Observable stream of ticks, emitting an array containing the current time and the tick delta.
-     */
-    get tick$(): Observable<[number, number]>;
     /**
      * Checks if the clock is currently running.
      */
@@ -54,12 +49,6 @@ export declare class PausableClock implements IClock {
      * @param parentClock The parent clock to synchronize with. Defaults to GgGlobalClock instance.
      */
     constructor(autoStart?: boolean, parentClock?: IClock);
-    /**
-     * Creates a child clock.
-     * @param autoStart Indicates whether the child clock should start automatically.
-     * @returns A new instance of PausableClock.
-     */
-    createChildClock(autoStart: boolean): PausableClock;
     /**
      * Starts the clock.
      */
@@ -84,4 +73,5 @@ export declare class PausableClock implements IClock {
      * Stops listening for ticks from the parent clock.
      */
     protected stopListeningTicks(): void;
+    dispose(): void;
 }

package/dist/base/clock/pausable-clock.js

@@ -1,16 +1,11 @@
 import { filter, Subject } from 'rxjs';
 import { map, tap } from 'rxjs/operators';
 import { GgGlobalClock } from './global-clock';
+import { IClock } from './i-clock';
 /**
  * A class providing the ability to track time, fire ticks, provide time elapsed, and tick delta with the ability to suspend/resume it.
  */
-export class PausableClock {
-    /**
-     * Observable stream of ticks, emitting an array containing the current time and the tick delta.
-     */
-    get tick$() {
-        return this._tick$.asObservable();
-    }
+export class PausableClock extends IClock {
     /**
      * Checks if the clock is currently running.
      */
@@ -76,10 +71,10 @@ export class PausableClock {
      * @param parentClock The parent clock to synchronize with. Defaults to GgGlobalClock instance.
      */
     constructor(autoStart = false, parentClock = GgGlobalClock.instance) {
+        super(parentClock);
         this.parentClock = parentClock;
         this.tickSub = null;
         this._internalTick$ = new Subject();
-        this._tick$ = new Subject();
         /**
          * Tick rate limiter. If set to 0 - tick rate is unlimited, 15 means "allow at most 15 ticks per second"
          */
@@ -103,14 +98,6 @@ export class PausableClock {
                 Math.floor((elapsed * this.tickRateLimit) / 1000)), tap(([elapsed]) => (this.lastFiredTickElapsed = elapsed)))
             .subscribe(this._tick$);
     }
-    /**
-     * Creates a child clock.
-     * @param autoStart Indicates whether the child clock should start automatically.
-     * @returns A new instance of PausableClock.
-     */
-    createChildClock(autoStart) {
-        return new PausableClock(autoStart, this);
-    }
     /**
      * Starts the clock.
      */
@@ -170,4 +157,9 @@ export class PausableClock {
         (_a = this.tickSub) === null || _a === void 0 ? void 0 : _a.unsubscribe();
         this.tickSub = null;
     }
+    dispose() {
+        this.stopListeningTicks();
+        this._internalTick$.complete();
+        super.dispose();
+    }
 }

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

@@ -16,6 +16,7 @@ export declare abstract class GgWorld<D, R, VTypeDoc extends VisualTypeDocRepo<D
     readonly physicsWorld: PW;
     private static default_name_counter;
     private static _documentWorlds;
+    static readonly worldCreated$: Subject<GgWorld<any, any>>;
     static get documentWorlds(): GgWorld<any, any>[];
     readonly worldClock: PausableClock;
     readonly keyboardInput: KeyboardInput;
@@ -26,6 +27,7 @@ export declare abstract class GgWorld<D, R, VTypeDoc extends VisualTypeDocRepo<D
     readonly tickForwardTo$: Subject<IEntity | 'PHYSICS_WORLD'>;
     readonly tickForwardedTo$: Subject<IEntity | 'PHYSICS_WORLD'>;
     readonly paused$: Subject<boolean>;
+    readonly disposed$: Subject<void>;
     protected constructor(visualScene: VS, physicsWorld: PW);
     init(): Promise<void>;
     start(): void;
@@ -40,4 +42,8 @@ export declare abstract class GgWorld<D, R, VTypeDoc extends VisualTypeDocRepo<D
     position?: D, rotation?: R, material?: unknown): IPositionable<D, R> & IRenderableEntity<D, R, VTypeDoc>;
     addEntity(entity: IEntity): void;
     removeEntity(entity: IEntity, dispose?: boolean): void;
+    private onGgStaticInitialized;
+    protected registerConsoleCommands(ggstatic: {
+        registerConsoleCommand: (world: GgWorld<any, any> | null, command: string, handler: (...args: string[]) => Promise<string>, doc?: string) => void;
+    }): void;
 }