@gg-web-engine/core 0.0.39 → 0.0.48

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

@@ -1,11 +1,11 @@
 import { BehaviorSubject, Observable, Subject } from 'rxjs';
-import { Graph, IEntity, Point3, Point4, TickOrder } from '../../base';
+import { Graph, IEntity, PausableClock, Point3, Point4, TickOrder } from '../../base';
 import { Gg3dWorld, PhysicsTypeDocRepo3D, VisualTypeDocRepo3D } from '../gg-3d-world';
 import { Entity3d } from './entity-3d';
 import { LoadOptions, LoadResultWithProps } from '../loader';
 import { IPositionable3d } from '../interfaces/i-positionable-3d';
 import { IRenderable3dEntity } from './i-renderable-3d.entity';
-export declare type MapGraphNodeType = {
+export type MapGraphNodeType = {
     path: string;
     position: Point3;
     rotation?: Point4;
@@ -33,14 +33,15 @@ export declare class MapGraph extends Graph<MapGraphNodeType> {
     getNearestDummy(thisNodes: Graph<MapGraphNodeType>[], cursor: Point3): Graph<MapGraphNodeType>;
     nodes(): MapGraph[];
 }
-export declare type Gg3dMapGraphEntityOptions = {
+export type Gg3dMapGraphEntityOptions = {
     loadDepth: number;
     inertia: number;
+    maxNodesLoadingPerTick: number;
 };
 export declare class MapGraph3dEntity<VTypeDoc extends VisualTypeDocRepo3D = VisualTypeDocRepo3D, PTypeDoc extends PhysicsTypeDocRepo3D = PhysicsTypeDocRepo3D> extends IRenderable3dEntity<VTypeDoc, PTypeDoc> {
     readonly mapGraph: MapGraph;
     readonly tickOrder = TickOrder.POST_RENDERING;
-    readonly loaderCursorEntity$: BehaviorSubject<(IEntity & IPositionable3d) | null>;
+    readonly loaderCursor$: BehaviorSubject<Point3>;
     readonly loaded: Map<MapGraphNodeType, (IEntity & IPositionable3d)[]>;
     private _initialLoadComplete$;
     get initialLoadComplete$(): Observable<boolean>;
@@ -60,10 +61,12 @@ export declare class MapGraph3dEntity<VTypeDoc extends VisualTypeDocRepo3D = Vis
             rotation: Point4;
         }
     ]>;
-    get world(): Gg3dWorld<VTypeDoc, PTypeDoc> | null;
-    protected _world: Gg3dWorld<VTypeDoc, PTypeDoc> | null;
     protected readonly mapGraphNodes: MapGraph[];
     protected readonly options: Gg3dMapGraphEntityOptions;
+    protected loadClock: PausableClock | null;
+    private _loadRateLimit;
+    get loadRateLimit(): number;
+    set loadRateLimit(value: number);
     constructor(mapGraph: MapGraph, options?: Partial<Gg3dMapGraphEntityOptions>);
     onSpawned(world: Gg3dWorld<VTypeDoc, PTypeDoc>): void;
     onRemoved(): void;

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 { distinctUntilChanged, map, tap, throttleTime } from 'rxjs/operators';
-import { Graph, Qtrn, TickOrder } from '../../base';
+import { BehaviorSubject, startWith, Subject, takeUntil } from 'rxjs';
+import { distinctUntilChanged, map, tap } from 'rxjs/operators';
+import { Graph, Pnt3, Qtrn, TickOrder } from '../../base';
 import { IRenderable3dEntity } from './i-renderable-3d.entity';
 export class MapGraph extends Graph {
     /**
@@ -79,41 +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._world = null;
+        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();
-    }
-    get world() {
-        return this._world;
-    }
     onSpawned(world) {
         super.onSpawned(world);
-        this.loaderCursorEntity$
-            .pipe(takeUntil(this._onRemoved$), switchMap(entity => entity
-            ? this.tick$.pipe(startWith(null), // map will perform initial loading even if world not started yet. Handy to preload map
-            takeUntil(entity.onRemoved$), throttleTime(1000), map(() => entity.position))
-            : NEVER), map(pos => this.mapGraph.getNearestDummy(this.mapGraphNodes, pos)), tap(node => this._nearestDummy$.next(node)), distinctUntilChanged())
-            .subscribe(currentChunk => {
+        this.loadClock = world.createClock(true);
+        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) {
@@ -132,18 +140,54 @@ 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() {
         super.onRemoved();
-        this.loaderCursorEntity$.next(null);
+        if (this.loadClock) {
+            this.loadClock.stop();
+            this.loadClock = 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;
 } & ({
@@ -51,6 +51,8 @@ export declare class RaycastVehicle3dEntity<VTypeDoc extends VisualTypeDocRepo3D
     protected readonly wheelLocalRotation: (Point4 | null)[];
     protected readonly frontWheelsIndices: number[];
     protected readonly rearWheelsIndices: number[];
+    get name(): string;
+    set name(value: string);
     getSpeed(): number;
     readonly tractionWheelRadius: number;
     private _steeringAngle;

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);
@@ -93,40 +134,13 @@ export class RaycastVehicle3dEntity extends Entity3d {
                 localRotation = { x: 0, y: 0.707107 * (flip ? 1 : -1), z: 0, w: 0.707107 };
             }
             this.wheelLocalRotation.push(localRotation);
-            this.wheels.push(new Entity3d(entity));
+            const wheelEntity = new Entity3d(entity);
+            wheelEntity.name = this.name + '__wheel_' + (options.isFront ? 'f' : 'r') + (options.isLeft ? 'l' : 'r');
+            this.wheels.push(wheelEntity);
         }
         this.addChildren(...this.wheels.filter(x => !!x));
         this.vehicleComponent.entity = this;
     }
-    // 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,15 +13,16 @@ 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;
     renderer: IRenderer3dComponent;
+    rendererExtraOpts: {};
     camera: ICameraComponent;
     texture: unknown;
 };
-export declare type PhysicsTypeDocRepo3D = {
+export type PhysicsTypeDocRepo3D = {
     factory: IPhysicsBody3dComponentFactory;
     loader: IPhysicsBody3dComponentLoader;
     rigidBody: IRigidBody3dComponent;
@@ -34,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.
@@ -6,6 +6,7 @@ import { IClock } from './i-clock';
 export declare class PausableClock implements 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.
@@ -35,12 +36,18 @@ export declare class PausableClock implements IClock {
      * Gets the elapsed time since the clock started.
      */
     get elapsedTime(): number;
+    /**
+     * 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;
     private lastStopElapsed;
     private _timeScale;
     private pausedByTimescale;
+    private lastFiredTickElapsed;
     /**
      * Constructs a new PausableClock instance.
      * @param autoStart Indicates whether the clock should start automatically upon creation.