@gg-web-engine/core 0.0.40 → 0.0.49

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

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

@@ -13,7 +13,7 @@ import { IVisualSceneComponent } from './i-visual-scene.component';
  * @property {number} [forceResolution] - Specifies the pixel resolution. Not set by default, which means "use device resolution".
  * @property {boolean} antialias - Specifies whether antialiasing is turned on/off. true by default.
  */
-export declare type RendererOptions = {
+export type RendererOptions = {
     transparent: boolean;
     background: number;
     size: Point2 | 'fullscreen' | ((pageSize: Point2) => Point2) | Observable<Point2>;

package/dist/base/data-structures/graph.js

@@ -1,8 +1,4 @@
 export class Graph {
-    constructor(data) {
-        this.data = data;
-        this.adjacent = new Set();
-    }
     /**
      * Creates a new Graph instance from an array of elements, where each element in the array is a node in the graph.
      * The first element of the array is used as the root node of the graph.
@@ -47,6 +43,10 @@ export class Graph {
         }
         return nodes[0][0];
     }
+    constructor(data) {
+        this.data = data;
+        this.adjacent = new Set();
+    }
     addAdjacent(node) {
         if (this.adjacent.has(node)) {
             return false;

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

@@ -1,7 +1,7 @@
 import { IEntity } from '../i-entity';
 import { Observable, Subject } from 'rxjs';
 import { GgWorld, PhysicsTypeDocRepo, VisualTypeDocRepo } from '../../gg-world';
-export declare type AnimationFunction<T> = (elapsed: number, delta: number) => T;
+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.
  * Supports smooth transition between animation function by interpolating between values over time.

package/dist/base/entities/controllers/animation-mixer.js

@@ -8,33 +8,6 @@ import { map, tap } from 'rxjs/operators';
  * The animation function can be changed with `transitAnimationFunction` or `transitFromStaticState`.
  */
 export class AnimationMixer extends IEntity {
-    /**
-     * Creates a new `AnimationMixer` entity.
-     * @param _animationFunction The initial motion control function that determines the animation.
-     * @param _lerp The linear interpolation between two values of type `T`.
-     */
-    constructor(_animationFunction, _lerp = (a, b, t) => b) {
-        super();
-        this._animationFunction = _animationFunction;
-        this._lerp = _lerp;
-        this.tickOrder = TickOrder.ANIMATION_MIXERS;
-        /**
-         * A subject that emits the current value of the animation on every tick.
-         */
-        this._value$ = new Subject();
-        /**
-         * The current transition time reference `[elapsed, delta]` that interpolates between the old and new functions.
-         */
-        this._currentTransitionK = [0, 0];
-        /**
-         * The current transition subscription, which is null if no transition is currently active.
-         */
-        this._currentTransition = null;
-        /**
-         * A behavior subject that emits whether the animator is currently in a transition.
-         */
-        this._isInTransition$ = new BehaviorSubject(false);
-    }
     /**
      * Gets an observable of the current value of the animation.
      */
@@ -76,6 +49,33 @@ export class AnimationMixer extends IEntity {
         this._currentTransition = value;
         this._isInTransition$.next(!!value);
     }
+    /**
+     * Creates a new `AnimationMixer` entity.
+     * @param _animationFunction The initial motion control function that determines the animation.
+     * @param _lerp The linear interpolation between two values of type `T`.
+     */
+    constructor(_animationFunction, _lerp = (a, b, t) => b) {
+        super();
+        this._animationFunction = _animationFunction;
+        this._lerp = _lerp;
+        this.tickOrder = TickOrder.ANIMATION_MIXERS;
+        /**
+         * A subject that emits the current value of the animation on every tick.
+         */
+        this._value$ = new Subject();
+        /**
+         * The current transition time reference `[elapsed, delta]` that interpolates between the old and new functions.
+         */
+        this._currentTransitionK = [0, 0];
+        /**
+         * The current transition subscription, which is null if no transition is currently active.
+         */
+        this._currentTransition = null;
+        /**
+         * A behavior subject that emits whether the animator is currently in a transition.
+         */
+        this._isInTransition$ = new BehaviorSubject(false);
+    }
     /**
      * Set output to static value and smoothly transit to new control function
      * @param newFunc a new function

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

@@ -6,21 +6,6 @@ import { distinctUntilChanged, map } from 'rxjs/operators';
  * @class
  */
 export class IRendererEntity extends IEntity {
-    /**
-     Initializes a new instance of the BaseGgRenderer class.
-     * @param renderer
-     */
-    constructor(renderer) {
-        super();
-        this.renderer = renderer;
-        this.tickOrder = TickOrder.RENDERING;
-        /** Represents the current size of the renderer. */
-        this._rendererSize$ = new BehaviorSubject(null);
-        this.addComponents(renderer);
-        this.tick$.subscribe(() => {
-            this.renderer.render();
-        });
-    }
     /**
      * Gets the observable that represents the current size of the renderer.
      * @returns {Observable<Point2 | null>} - An observable that represents the size of the renderer.
@@ -46,6 +31,21 @@ export class IRendererEntity extends IEntity {
     set physicsDebugViewActive(value) {
         this.renderer.physicsDebugViewActive = value;
     }
+    /**
+     Initializes a new instance of the BaseGgRenderer class.
+     * @param renderer
+     */
+    constructor(renderer) {
+        super();
+        this.renderer = renderer;
+        this.tickOrder = TickOrder.RENDERING;
+        /** Represents the current size of the renderer. */
+        this._rendererSize$ = new BehaviorSubject(null);
+        this.addComponents(renderer);
+        this.tick$.subscribe(() => {
+            this.renderer.render();
+        });
+    }
     onSpawned(world) {
         this._rendererSize$.next(null);
         if (this.rendererOptions.size == 'fullscreen' || typeof this.rendererOptions.size === 'function') {

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

@@ -1,12 +1,12 @@
 import { IDisplayObjectComponent, IEntity, IPhysicsWorldComponent, IPositionable, IRenderableEntity, IRendererComponent, IRigidBodyComponent, ITriggerComponent, IVisualSceneComponent, KeyboardInput, PausableClock } from '../base';
 import { Subject } from 'rxjs';
-export declare type VisualTypeDocRepo<D, R> = {
+export type VisualTypeDocRepo<D, R> = {
     factory: unknown;
     displayObject: IDisplayObjectComponent<D, R>;
     renderer: IRendererComponent<D, R>;
     rendererExtraOpts: {};
 };
-export declare type PhysicsTypeDocRepo<D, R> = {
+export type PhysicsTypeDocRepo<D, R> = {
     factory: unknown;
     rigidBody: IRigidBodyComponent<D, R>;
     trigger: ITriggerComponent<D, R>;
@@ -25,6 +25,7 @@ export declare abstract class GgWorld<D, R, VTypeDoc extends VisualTypeDocRepo<D
     readonly tickStarted$: Subject<void>;
     readonly tickForwardTo$: Subject<IEntity | 'PHYSICS_WORLD'>;
     readonly tickForwardedTo$: Subject<IEntity | 'PHYSICS_WORLD'>;
+    readonly paused$: Subject<boolean>;
     protected constructor(visualScene: VS, physicsWorld: PW);
     init(): Promise<void>;
     start(): void;

package/dist/base/gg-world.js

@@ -11,6 +11,9 @@ import { GgGlobalClock, IRendererEntity, KeyboardInput, TickOrder, } from '../ba
 import { lastValueFrom, Subject, take } from 'rxjs';
 import { PerformanceMeterEntity } from '../dev';
 export class GgWorld {
+    static get documentWorlds() {
+        return [...GgWorld._documentWorlds];
+    }
     constructor(visualScene, physicsWorld) {
         this.visualScene = visualScene;
         this.physicsWorld = physicsWorld;
@@ -24,6 +27,7 @@ export class GgWorld {
         this.tickStarted$ = new Subject();
         this.tickForwardTo$ = new Subject();
         this.tickForwardedTo$ = new Subject();
+        this.paused$ = new Subject();
         GgWorld._documentWorlds.push(this);
         this.keyboardInput.start();
         if (window.ggstatic) {
@@ -89,9 +93,7 @@ export class GgWorld {
                 'entity in world. Arguments are samples amount (20 by default) and "peak" or "avg" choice, both arguments are ' +
                 'optional. "avg" report sorts entities by average time consumed, "peak" records highest value for each entity');
         }
-    }
-    static get documentWorlds() {
-        return [...GgWorld._documentWorlds];
+        this.worldClock.paused$.subscribe(this.paused$);
     }
     init() {
         return __awaiter(this, void 0, void 0, function* () {

package/dist/base/index.d.ts

@@ -33,4 +33,5 @@ export * from './math/quaternion';
 export * from './math/numbers';
 export * from './math/matrix4';
 export * from './math/splines';
+export * from './pipes/gg-elastic.pipe';
 export * from './gg-world';

package/dist/base/index.js

@@ -33,4 +33,5 @@ export * from './math/quaternion';
 export * from './math/numbers';
 export * from './math/matrix4';
 export * from './math/splines';
+export * from './pipes/gg-elastic.pipe';
 export * from './gg-world';

package/dist/base/inputs/direction.keyboard.input.d.ts

@@ -4,11 +4,11 @@ import { IInput } from './i-input';
 /**
  * The type representing desired keymap for DirectionKeyboardInput
  */
-export declare type DirectionKeyboardKeymap = 'arrows' | 'wasd' | 'wasd+arrows';
+export type DirectionKeyboardKeymap = 'arrows' | 'wasd' | 'wasd+arrows';
 /**
  * The type of DirectionKeyboardInput output value
  */
-export declare type DirectionKeyboardOutput = {
+export type DirectionKeyboardOutput = {
     upDown?: boolean;
     leftRight?: boolean;
 };

package/dist/base/inputs/direction.keyboard.input.js

@@ -6,6 +6,12 @@ import { IInput } from './i-input';
  * Supports two the most popular keyboard layouts: WASD and arrows.
  */
 export class DirectionKeyboardInput extends IInput {
+    /**
+     * Returns an observable that emits `DirectionKeyboardOutput` objects whenever the input changes.
+     */
+    get output$() {
+        return this._output$.asObservable();
+    }
     /**
      * Creates a new instance of the `DirectionKeyboardInput` class.
      *
@@ -21,12 +27,6 @@ export class DirectionKeyboardInput extends IInput {
          */
         this._output$ = new Subject();
     }
-    /**
-     * Returns an observable that emits `DirectionKeyboardOutput` objects whenever the input changes.
-     */
-    get output$() {
-        return this._output$.asObservable();
-    }
     /**
      * Called when the input handling should start.
      */