@gg-web-engine/core 0.0.40 → 0.0.48

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

@@ -7,9 +7,9 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-import { BehaviorSubject, NEVER, startWith, Subject, switchMap, takeUntil } from 'rxjs';
+import { BehaviorSubject, startWith, Subject, takeUntil } from 'rxjs';
 import { distinctUntilChanged, map, tap } from 'rxjs/operators';
-import { Graph, Qtrn, TickOrder } from '../../base';
+import { Graph, Pnt3, Qtrn, TickOrder } from '../../base';
 import { IRenderable3dEntity } from './i-renderable-3d.entity';
 export class MapGraph extends Graph {
     /**
@@ -79,40 +79,49 @@ export class MapGraph extends Graph {
 const defaultOptions = {
     loadDepth: 5,
     inertia: 0,
+    maxNodesLoadingPerTick: 1,
 };
 export class MapGraph3dEntity extends IRenderable3dEntity {
+    get initialLoadComplete$() {
+        return this._initialLoadComplete$.asObservable();
+    }
+    get nearestDummy() {
+        return this._nearestDummy$.getValue();
+    }
+    get chunkLoaded$() {
+        return this._chunkLoaded$.asObservable();
+    }
+    get loadRateLimit() {
+        return this._loadRateLimit;
+    }
+    set loadRateLimit(value) {
+        this._loadRateLimit = value;
+        if (this.loadClock) {
+            this.loadClock.tickRateLimit = value;
+        }
+    }
     constructor(mapGraph, options = {}) {
         super();
         this.mapGraph = mapGraph;
         this.tickOrder = TickOrder.POST_RENDERING;
-        this.loaderCursorEntity$ = new BehaviorSubject(null);
+        this.loaderCursor$ = new BehaviorSubject(Pnt3.O);
         this.loaded = new Map();
         this._initialLoadComplete$ = new BehaviorSubject(false);
         this._nearestDummy$ = new BehaviorSubject(null);
         this._chunkLoaded$ = new Subject();
         this.loadClock = null;
+        this._loadRateLimit = 1;
         this.options = Object.assign(Object.assign({}, defaultOptions), options);
         this.mapGraphNodes = mapGraph.nodes();
     }
-    get initialLoadComplete$() {
-        return this._initialLoadComplete$.asObservable();
-    }
-    get nearestDummy() {
-        return this._nearestDummy$.getValue();
-    }
-    get chunkLoaded$() {
-        return this._chunkLoaded$.asObservable();
-    }
     onSpawned(world) {
         super.onSpawned(world);
         this.loadClock = world.createClock(true);
-        this.loadClock.tickRateLimit = 1;
-        this.loaderCursorEntity$
-            .pipe(takeUntil(this._onRemoved$), switchMap(entity => entity
-            ? this.loadClock.tick$.pipe(startWith(null), // map will perform initial loading even if world not started yet. Handy to preload map
-            takeUntil(entity.onRemoved$), map(() => entity.position))
-            : NEVER), map(pos => this.mapGraph.getNearestDummy(this.mapGraphNodes, pos)), tap(node => this._nearestDummy$.next(node)), distinctUntilChanged())
-            .subscribe(currentChunk => {
+        this.loadClock.tickRateLimit = this._loadRateLimit;
+        let loadList = [];
+        let unloadList = [];
+        this.loadClock.tick$.pipe(startWith(null), // map will perform initial loading even if world not started yet. Handy to preload map
+        takeUntil(this._onRemoved$), map(() => this.mapGraph.getNearestDummy(this.mapGraphNodes, this.loaderCursor$.getValue())), distinctUntilChanged(), tap(node => this._nearestDummy$.next(node))).subscribe(currentChunk => {
             let haveToBeLoaded = new Set();
             let canBeLoaded;
             if (this.options.inertia > 0) {
@@ -131,13 +140,45 @@ export class MapGraph3dEntity extends IRenderable3dEntity {
             }
             for (const loadedNode of this.loaded.keys()) {
                 if (!canBeLoaded.has(loadedNode)) {
-                    this.disposeChunk(loadedNode);
+                    if (!unloadList.includes(loadedNode)) {
+                        unloadList.push(loadedNode);
+                    }
                 }
                 else {
                     haveToBeLoaded.delete(loadedNode);
                 }
             }
-            Promise.all(Array.from(haveToBeLoaded.keys()).map(n => this.loadChunk(n))).then(() => this._initialLoadComplete$.next(true));
+            for (let n of Array.from(haveToBeLoaded.keys())) {
+                if (!loadList.includes(n)) {
+                    loadList.push(n);
+                }
+            }
+        });
+        this.tick$
+            .pipe(startWith(null), // map will perform initial loading even if world not started yet. Handy to preload map
+        takeUntil(this._onRemoved$))
+            .subscribe(() => {
+            if (unloadList.length) {
+                for (const n of unloadList) {
+                    this.disposeChunk(n);
+                }
+                unloadList = [];
+            }
+            if (loadList.length) {
+                if (this._initialLoadComplete$.value && loadList.length > this.options.maxNodesLoadingPerTick) {
+                    let loadNow = loadList.slice(0, this.options.maxNodesLoadingPerTick);
+                    loadList = loadList.slice(this.options.maxNodesLoadingPerTick);
+                    Promise.all(loadNow.map(n => this.loadChunk(n))).then();
+                }
+                else {
+                    Promise.all(loadList.map(n => this.loadChunk(n))).then(() => {
+                        if (!this._initialLoadComplete$.value) {
+                            this._initialLoadComplete$.next(true);
+                        }
+                    });
+                    loadList = [];
+                }
+            }
         });
     }
     onRemoved() {
@@ -146,7 +187,7 @@ export class MapGraph3dEntity extends IRenderable3dEntity {
             this.loadClock.stop();
             this.loadClock = null;
         }
-        this.loaderCursorEntity$.next(null);
+        this.loaderCursor$.next(Pnt3.O);
     }
     loadChunk(node) {
         return __awaiter(this, void 0, void 0, function* () {

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

@@ -4,12 +4,12 @@ import { IDisplayObject3dComponent } from '../components/rendering/i-display-obj
 import { IRaycastVehicleComponent, SuspensionOptions } from '../components/physics/i-raycast-vehicle.component';
 import { IRigidBody3dComponent } from '../components/physics/i-rigid-body-3d.component';
 import { PhysicsTypeDocRepo3D, VisualTypeDocRepo3D } from '../gg-3d-world';
-export declare type WheelDisplayOptions = {
+export type WheelDisplayOptions = {
     displayObject?: IDisplayObject3dComponent;
     wheelObjectDirection?: AxisDirection3;
     autoScaleMesh?: boolean;
 };
-export declare type RVEntitySharedWheelOptions = {
+export type RVEntitySharedWheelOptions = {
     tyreWidth?: number;
     tyreRadius?: number;
     frictionSlip?: number;
@@ -17,7 +17,7 @@ export declare type RVEntitySharedWheelOptions = {
     maxTravel?: number;
     display?: WheelDisplayOptions;
 };
-export declare type RVEntityAxleOptions = {
+export type RVEntityAxleOptions = {
     halfAxleWidth: number;
     axlePosition: number;
     axleHeight: number;
@@ -26,7 +26,7 @@ export declare enum RVEntityTractionBias {
     FWD = 1,
     RWD = 0
 }
-export declare type RVEntityProperties = {
+export type RVEntityProperties = {
     tractionBias: RVEntityTractionBias | number;
     suspension: SuspensionOptions;
 } & ({

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

@@ -13,6 +13,47 @@ const wheeelDefaults = {
     maxTravel: 0.5,
 };
 export class RaycastVehicle3dEntity extends Entity3d {
+    get name() {
+        return super.name;
+    }
+    set name(value) {
+        const oldName = super.name;
+        super.name = value;
+        for (const w of this.wheels || []) {
+            if (w) {
+                w.name = w.name.replace(oldName, value);
+            }
+        }
+    }
+    // m/s
+    getSpeed() {
+        return this.vehicleComponent.wheelSpeed;
+    }
+    get steeringAngle() {
+        return this._steeringAngle;
+    }
+    set steeringAngle(value) {
+        if (this._steeringAngle != value) {
+            this._steeringAngle = value;
+        }
+        this.frontWheelsIndices.forEach(index => this.vehicleComponent.setSteering(index, value));
+    }
+    applyTraction(axle, force) {
+        if (axle != 'rear') {
+            this.frontWheelsIndices.forEach(index => this.vehicleComponent.applyEngineForce(index, force));
+        }
+        if (axle != 'front') {
+            this.rearWheelsIndices.forEach(index => this.vehicleComponent.applyEngineForce(index, force));
+        }
+    }
+    applyBrake(axle, force) {
+        if (axle != 'rear') {
+            this.frontWheelsIndices.forEach(index => this.vehicleComponent.applyBrake(index, force));
+        }
+        if (axle != 'front') {
+            this.rearWheelsIndices.forEach(index => this.vehicleComponent.applyBrake(index, force));
+        }
+    }
     /** car mesh and physics body direction has to be pointing: y front, z up*/
     constructor(carProperties, chassis3D, vehicleComponent) {
         super(chassis3D, vehicleComponent);
@@ -100,47 +141,6 @@ export class RaycastVehicle3dEntity extends Entity3d {
         this.addChildren(...this.wheels.filter(x => !!x));
         this.vehicleComponent.entity = this;
     }
-    get name() {
-        return super.name;
-    }
-    set name(value) {
-        const oldName = super.name;
-        super.name = value;
-        for (const w of this.wheels || []) {
-            if (w) {
-                w.name = w.name.replace(oldName, value);
-            }
-        }
-    }
-    // m/s
-    getSpeed() {
-        return this.vehicleComponent.wheelSpeed;
-    }
-    get steeringAngle() {
-        return this._steeringAngle;
-    }
-    set steeringAngle(value) {
-        if (this._steeringAngle != value) {
-            this._steeringAngle = value;
-        }
-        this.frontWheelsIndices.forEach(index => this.vehicleComponent.setSteering(index, value));
-    }
-    applyTraction(axle, force) {
-        if (axle != 'rear') {
-            this.frontWheelsIndices.forEach(index => this.vehicleComponent.applyEngineForce(index, force));
-        }
-        if (axle != 'front') {
-            this.rearWheelsIndices.forEach(index => this.vehicleComponent.applyEngineForce(index, force));
-        }
-    }
-    applyBrake(axle, force) {
-        if (axle != 'rear') {
-            this.frontWheelsIndices.forEach(index => this.vehicleComponent.applyBrake(index, force));
-        }
-        if (axle != 'front') {
-            this.rearWheelsIndices.forEach(index => this.vehicleComponent.applyBrake(index, force));
-        }
-    }
     runTransformBinding(objectBody, object3D) {
         super.runTransformBinding(objectBody, object3D);
         for (const [i, wheel] of (this.wheels || []).entries()) {

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

@@ -1,17 +1,6 @@
 import { IEntity, Pnt3, Qtrn, TickOrder } from '../../base';
 import { map } from 'rxjs/operators';
 export class Trigger3dEntity extends IEntity {
-    constructor(objectBody) {
-        super();
-        this.objectBody = objectBody;
-        this.tickOrder = TickOrder.OBJECTS_BINDING;
-        this._position = Pnt3.O;
-        this._rotation = Qtrn.O;
-        this.tick$.subscribe(() => {
-            this.objectBody.checkOverlaps();
-        });
-        this.addComponents(this.objectBody);
-    }
     get onEntityEntered() {
         return this.objectBody.onEntityEntered.pipe(map(c => c.entity));
     }
@@ -32,4 +21,15 @@ export class Trigger3dEntity extends IEntity {
         this.objectBody.rotation = value;
         this._rotation = value;
     }
+    constructor(objectBody) {
+        super();
+        this.objectBody = objectBody;
+        this.tickOrder = TickOrder.OBJECTS_BINDING;
+        this._position = Pnt3.O;
+        this._rotation = Qtrn.O;
+        this.tick$.subscribe(() => {
+            this.objectBody.checkOverlaps();
+        });
+        this.addComponents(this.objectBody);
+    }
 }

package/dist/3d/factories.d.ts

@@ -1,7 +1,7 @@
 import { BodyShape3DDescriptor, Shape3DDescriptor, Shape3DMeshDescriptor } from './models/shapes';
 import { Point3, Point4 } from '../base';
 import { PhysicsTypeDocRepo3D, VisualTypeDocRepo3D } from './gg-3d-world';
-export declare type DisplayObject3dOpts<Tex> = {
+export type DisplayObject3dOpts<Tex> = {
     color?: number;
     shading?: 'unlit' | 'standart' | 'phong' | 'wireframe';
     diffuse?: Tex;

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

@@ -13,7 +13,7 @@ import { IRaycastVehicleComponent } from './components/physics/i-raycast-vehicle
 import { IRigidBody3dComponent } from './components/physics/i-rigid-body-3d.component';
 import { ITrigger3dComponent } from './components/physics/i-trigger-3d.component';
 import { IDisplayObject3dComponentLoader, IPhysicsBody3dComponentLoader } from './loaders';
-export declare type VisualTypeDocRepo3D = {
+export type VisualTypeDocRepo3D = {
     factory: IDisplayObject3dComponentFactory;
     loader: IDisplayObject3dComponentLoader;
     displayObject: IDisplayObject3dComponent;
@@ -22,7 +22,7 @@ export declare type VisualTypeDocRepo3D = {
     camera: ICameraComponent;
     texture: unknown;
 };
-export declare type PhysicsTypeDocRepo3D = {
+export type PhysicsTypeDocRepo3D = {
     factory: IPhysicsBody3dComponentFactory;
     loader: IPhysicsBody3dComponentLoader;
     rigidBody: IRigidBody3dComponent;
@@ -35,5 +35,5 @@ export declare class Gg3dWorld<VTypeDoc extends VisualTypeDocRepo3D = VisualType
     readonly loader: Gg3dLoader<VTypeDoc, PTypeDoc>;
     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>): Renderer3dEntity<VTypeDoc>;
+    addRenderer(camera: VTypeDoc['camera'], canvas?: HTMLCanvasElement, rendererOptions?: Partial<RendererOptions & VTypeDoc['rendererExtraOpts']>): Renderer3dEntity<VTypeDoc>;
 }

package/dist/3d/loader.d.ts

@@ -7,25 +7,25 @@ export declare enum CachingStrategy {
     Files = 1,
     Entities = 2
 }
-export declare type LoadOptions = {
+export type LoadOptions = {
     cachingStrategy: CachingStrategy;
     position: Point3;
     rotation: Point4;
     loadProps: boolean;
     propsPath?: string;
 };
-export declare type LoadResourcesResult<VTypeDoc extends VisualTypeDocRepo3D = VisualTypeDocRepo3D, PTypeDoc extends PhysicsTypeDocRepo3D = PhysicsTypeDocRepo3D> = {
+export type LoadResourcesResult<VTypeDoc extends VisualTypeDocRepo3D = VisualTypeDocRepo3D, PTypeDoc extends PhysicsTypeDocRepo3D = PhysicsTypeDocRepo3D> = {
     resources: {
         object3D: VTypeDoc['displayObject'] | null;
         body: PTypeDoc['rigidBody'] | null;
     }[];
     meta: GgMeta;
 };
-export declare type LoadResult<VTypeDoc extends VisualTypeDocRepo3D = VisualTypeDocRepo3D, PTypeDoc extends PhysicsTypeDocRepo3D = PhysicsTypeDocRepo3D> = {
+export type LoadResult<VTypeDoc extends VisualTypeDocRepo3D = VisualTypeDocRepo3D, PTypeDoc extends PhysicsTypeDocRepo3D = PhysicsTypeDocRepo3D> = {
     entities: Entity3d<VTypeDoc, PTypeDoc>[];
     meta: GgMeta;
 };
-export declare type LoadResultWithProps<VTypeDoc extends VisualTypeDocRepo3D = VisualTypeDocRepo3D, PTypeDoc extends PhysicsTypeDocRepo3D = PhysicsTypeDocRepo3D> = LoadResult<VTypeDoc, PTypeDoc> & {
+export type LoadResultWithProps<VTypeDoc extends VisualTypeDocRepo3D = VisualTypeDocRepo3D, PTypeDoc extends PhysicsTypeDocRepo3D = PhysicsTypeDocRepo3D> = LoadResult<VTypeDoc, PTypeDoc> & {
     props?: LoadResult<VTypeDoc, PTypeDoc>[];
 };
 export declare class Gg3dLoader<VTypeDoc extends VisualTypeDocRepo3D = VisualTypeDocRepo3D, PTypeDoc extends PhysicsTypeDocRepo3D = PhysicsTypeDocRepo3D> {

package/dist/3d/loader.js

@@ -22,7 +22,7 @@ const defaultLoadOptions = {
     loadProps: true,
 };
 const cloneLoadResourcesResult = (loadResult) => ({
-    meta: loadResult.meta,
+    meta: loadResult.meta, // TODO deep clone it
     resources: loadResult.resources.map(({ object3D, body }) => ({
         object3D: object3D && object3D.clone(),
         body: body && body.clone(),
@@ -34,8 +34,8 @@ export class Gg3dLoader {
         this.filesCache = new Map();
         this.loadResultCache = new Map();
     }
-    loadGgGlbFiles(path, useCache = false) {
-        return __awaiter(this, void 0, void 0, function* () {
+    loadGgGlbFiles(path_1) {
+        return __awaiter(this, arguments, void 0, function* (path, useCache = false) {
             if (useCache && this.filesCache.has(path)) {
                 return this.filesCache.get(path);
             }
@@ -55,8 +55,8 @@ export class Gg3dLoader {
             return result;
         });
     }
-    loadGgGlbResources(path, cachingStrategy = CachingStrategy.Nothing) {
-        return __awaiter(this, void 0, void 0, function* () {
+    loadGgGlbResources(path_1) {
+        return __awaiter(this, arguments, void 0, function* (path, cachingStrategy = CachingStrategy.Nothing) {
             if (cachingStrategy == CachingStrategy.Entities && this.loadResultCache.has(path)) {
                 const cached = this.loadResultCache.get(path);
                 const cachedResult = cached instanceof Promise ? yield cached : cached;
@@ -94,8 +94,8 @@ export class Gg3dLoader {
             return result;
         });
     }
-    loadGgGlb(path, options = defaultLoadOptions) {
-        return __awaiter(this, void 0, void 0, function* () {
+    loadGgGlb(path_1) {
+        return __awaiter(this, arguments, void 0, function* (path, options = defaultLoadOptions) {
             const loadOptions = Object.assign(Object.assign({}, defaultLoadOptions), options);
             const { resources, meta } = yield this.loadGgGlbResources(path, loadOptions.cachingStrategy);
             const result = {

package/dist/3d/models/body-options.d.ts

@@ -2,6 +2,6 @@ import { BodyOptions, DebugBodySettings } from '../../base';
 import { Shape3DDescriptor } from './shapes';
 export interface Body3DOptions extends BodyOptions {
 }
-export declare type DebugBody3DSettings = DebugBodySettings & {
+export type DebugBody3DSettings = DebugBodySettings & {
     shape: Shape3DDescriptor;
 };

package/dist/3d/models/gg-meta.d.ts

@@ -1,21 +1,21 @@
 import { Point3, Point4 } from '../../base';
 import { BodyShape3DDescriptor } from './shapes';
-export declare type GgDummy = {
+export type GgDummy = {
     name: string;
     position: Point3;
     rotation: Point4;
 } & any;
-export declare type GgCurve = {
+export type GgCurve = {
     name: string;
     cyclic: boolean;
     points: Point3[];
 } & any;
-export declare type GgRigidBody = {
+export type GgRigidBody = {
     name: string;
     position: Point3;
     rotation: Point4;
 } & BodyShape3DDescriptor;
-export declare type GgMeta = {
+export type GgMeta = {
     dummies: GgDummy[];
     curves: GgCurve[];
     rigidBodies: GgRigidBody[];

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

@@ -1,6 +1,6 @@
 import { Point2, Point3, Point4 } from '../../base';
 import { Body3DOptions } from './body-options';
-export declare type Shape3DDescriptor = {
+export type Shape3DDescriptor = {
     shape: 'PLANE';
 } | {
     shape: 'BOX';
@@ -31,7 +31,7 @@ export declare type Shape3DDescriptor = {
     vertices: Point3[];
     faces: [number, number, number][];
 };
-export declare type Shape3DMeshDescriptor = {
+export type Shape3DMeshDescriptor = {
     shape: 'PLANE';
     dimensions?: Point2;
     segments?: Point2;
@@ -71,7 +71,7 @@ export declare type Shape3DMeshDescriptor = {
     vertices: Point3[];
     faces: [number, number, number][];
 };
-export declare type BodyShape3DDescriptor = {
+export type BodyShape3DDescriptor = {
     shape: Shape3DDescriptor;
     body: Partial<Body3DOptions>;
 };

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

@@ -6,14 +6,6 @@ import { PausableClock } from './pausable-clock';
  * Starts as soon as accessed and counts time from 01/01/1970
  */
 export class GgGlobalClock {
-    constructor() {
-        this._tick$ = new Subject();
-        let oldRelativeTime = this.elapsedTime;
-        of(undefined, animationFrameScheduler)
-            .pipe(repeat())
-            .pipe(map(() => [oldRelativeTime, this.elapsedTime]), tap(([_, cur]) => (oldRelativeTime = cur)))
-            .subscribe(this._tick$);
-    }
     static get instance() {
         if (!GgGlobalClock._instance) {
             GgGlobalClock._instance = new GgGlobalClock();
@@ -29,4 +21,12 @@ export class GgGlobalClock {
     createChildClock(autoStart) {
         return new PausableClock(autoStart, this);
     }
+    constructor() {
+        this._tick$ = new Subject();
+        let oldRelativeTime = this.elapsedTime;
+        of(undefined, animationFrameScheduler)
+            .pipe(repeat())
+            .pipe(map(() => [oldRelativeTime, this.elapsedTime]), tap(([_, cur]) => (oldRelativeTime = cur)))
+            .subscribe(this._tick$);
+    }
 }

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

@@ -1,4 +1,4 @@
-import { Observable } from 'rxjs';
+import { Observable, 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.
@@ -40,6 +40,7 @@ export declare class PausableClock implements IClock {
      * Tick rate limiter. If set to 0 - tick rate is unlimited, 15 means "allow at most 15 ticks per second"
      */
     tickRateLimit: number;
+    readonly paused$: Subject<boolean>;
     private startedAt;
     private oldRelativeTime;
     private pausedAt;

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

@@ -5,37 +5,6 @@ import { GgGlobalClock } from './global-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 {
-    /**
-     * Constructs a new PausableClock instance.
-     * @param autoStart Indicates whether the clock should start automatically upon creation.
-     * @param parentClock The parent clock to synchronize with. Defaults to GgGlobalClock instance.
-     */
-    constructor(autoStart = false, parentClock = GgGlobalClock.instance) {
-        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"
-         */
-        this.tickRateLimit = 0;
-        // State variables
-        this.startedAt = -1;
-        this.oldRelativeTime = 0; // "elapsed", emitted on last tick
-        this.pausedAt = -1;
-        this.lastStopElapsed = 0;
-        this._timeScale = 1;
-        this.pausedByTimescale = false;
-        this.lastFiredTickElapsed = 0;
-        if (autoStart) {
-            this.start();
-        }
-        this._internalTick$
-            .pipe(map(([_, newTime]) => [newTime, newTime - this.lastFiredTickElapsed]), filter(([elapsed]) => !this.tickRateLimit ||
-            Math.floor((this.lastFiredTickElapsed * this.tickRateLimit) / 1000) <
-                Math.floor((elapsed * this.tickRateLimit) / 1000)), tap(([elapsed]) => (this.lastFiredTickElapsed = elapsed)))
-            .subscribe(this._tick$);
-    }
     /**
      * Observable stream of ticks, emitting an array containing the current time and the tick delta.
      */
@@ -101,6 +70,39 @@ export class PausableClock {
         }
         return this._timeScale * (this.parentClock.elapsedTime - this.startedAt);
     }
+    /**
+     * Constructs a new PausableClock instance.
+     * @param autoStart Indicates whether the clock should start automatically upon creation.
+     * @param parentClock The parent clock to synchronize with. Defaults to GgGlobalClock instance.
+     */
+    constructor(autoStart = false, parentClock = GgGlobalClock.instance) {
+        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"
+         */
+        this.tickRateLimit = 0;
+        // events
+        this.paused$ = new Subject();
+        // State variables
+        this.startedAt = -1;
+        this.oldRelativeTime = 0; // "elapsed", emitted on last tick
+        this.pausedAt = -1;
+        this.lastStopElapsed = 0;
+        this._timeScale = 1;
+        this.pausedByTimescale = false;
+        this.lastFiredTickElapsed = 0;
+        if (autoStart) {
+            this.start();
+        }
+        this._internalTick$
+            .pipe(map(([_, newTime]) => [newTime, newTime - this.lastFiredTickElapsed]), filter(([elapsed]) => !this.tickRateLimit ||
+            Math.floor((this.lastFiredTickElapsed * this.tickRateLimit) / 1000) <
+                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.
@@ -135,6 +137,7 @@ export class PausableClock {
         this.stopListeningTicks();
         this.pausedAt = this.parentClock.elapsedTime;
         this.pausedByTimescale = false;
+        this.paused$.next(true);
     }
     /**
      * Resumes the clock.
@@ -146,6 +149,7 @@ export class PausableClock {
         this.startedAt += this.parentClock.elapsedTime - this.pausedAt;
         this.pausedAt = -1;
         this.startListeningTicks();
+        this.paused$.next(false);
     }
     /**
      * Starts listening for ticks from the parent clock.