@gg-web-engine/core 0.0.1 → 0.0.3

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

@@ -0,0 +1,25 @@
+import { Observable } from 'rxjs';
+import { GgGlobalClock } from './global-clock';
+/**
+ * A class, providing ability to track time, fire ticks, provide time elapsed + tick delta with ability to suspend/resume it.
+ */
+export declare class Clock {
+    protected readonly parentClock: Clock | GgGlobalClock;
+    private tickSub;
+    private readonly _tick$;
+    get tick$(): Observable<[number, number]>;
+    get isRunning(): boolean;
+    get isPaused(): boolean;
+    get elapsedTime(): number;
+    private startedAt;
+    private oldRelativeTime;
+    private pausedAt;
+    constructor(autoStart?: boolean, parentClock?: Clock | GgGlobalClock);
+    createChildClock(autoStart: boolean): Clock;
+    start(): void;
+    stop(): void;
+    pause(): void;
+    resume(): void;
+    protected startListeningTicks(): void;
+    protected stopListeningTicks(): void;
+}

package/dist/base/clock/clock.js

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Clock = void 0;
+const rxjs_1 = require("rxjs");
+const operators_1 = require("rxjs/operators");
+const global_clock_1 = require("./global-clock");
+/**
+ * A class, providing ability to track time, fire ticks, provide time elapsed + tick delta with ability to suspend/resume it.
+ */
+class Clock {
+    constructor(autoStart = false, parentClock = global_clock_1.GgGlobalClock.instance) {
+        this.parentClock = parentClock;
+        this.tickSub = null;
+        this._tick$ = new rxjs_1.Subject();
+        // state
+        this.startedAt = -1;
+        this.oldRelativeTime = 0; // "elapsed", emitted on last tick
+        this.pausedAt = -1;
+        if (autoStart) {
+            this.start();
+        }
+    }
+    get tick$() {
+        return this._tick$.pipe((0, operators_1.map)(([oldTime, newTime]) => [newTime, newTime - oldTime]));
+    }
+    get isRunning() {
+        return !!this.tickSub;
+    }
+    get isPaused() {
+        return this.pausedAt !== -1;
+    }
+    get elapsedTime() {
+        if (this.isPaused) {
+            return this.pausedAt - this.startedAt;
+        }
+        return this.parentClock.elapsedTime - this.startedAt;
+    }
+    createChildClock(autoStart) {
+        return new Clock(autoStart, this);
+    }
+    start() {
+        if (this.isRunning) {
+            return;
+        }
+        this.oldRelativeTime = 0;
+        this.startedAt = this.parentClock.elapsedTime;
+        this.startListeningTicks();
+    }
+    stop() {
+        this.stopListeningTicks();
+        this.startedAt = this.pausedAt = -1;
+    }
+    pause() {
+        this.stopListeningTicks();
+        this.pausedAt = this.parentClock.elapsedTime;
+    }
+    resume() {
+        if (this.isRunning || this.pausedAt == -1) {
+            return;
+        }
+        this.startedAt += this.parentClock.elapsedTime - this.pausedAt;
+        this.pausedAt = -1;
+        this.startListeningTicks();
+    }
+    startListeningTicks() {
+        if (this.tickSub) {
+            throw new Error('Clock is already ticking!');
+        }
+        this.tickSub = this.parentClock.tick$
+            .pipe((0, operators_1.map)(([parentElapsed, _]) => [this.oldRelativeTime, parentElapsed - this.startedAt]), (0, operators_1.tap)(([_, cur]) => (this.oldRelativeTime = cur)))
+            .subscribe(this._tick$);
+    }
+    stopListeningTicks() {
+        var _a;
+        (_a = this.tickSub) === null || _a === void 0 ? void 0 : _a.unsubscribe();
+        this.tickSub = null;
+    }
+}
+exports.Clock = Clock;

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

@@ -0,0 +1,15 @@
+import { Observable } from 'rxjs';
+import { Clock } from './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 {
+    private static _instance;
+    static get instance(): GgGlobalClock;
+    private readonly _tick$;
+    get tick$(): Observable<[number, number]>;
+    get elapsedTime(): number;
+    createChildClock(autoStart: boolean): Clock;
+    private constructor();
+}

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

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GgGlobalClock = void 0;
+const rxjs_1 = require("rxjs");
+const operators_1 = require("rxjs/operators");
+const clock_1 = require("./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
+ */
+class GgGlobalClock {
+    constructor() {
+        this._tick$ = new rxjs_1.Subject();
+        let oldRelativeTime = this.elapsedTime;
+        (0, rxjs_1.of)(undefined, rxjs_1.animationFrameScheduler)
+            .pipe((0, operators_1.repeat)())
+            .pipe((0, operators_1.map)(() => [oldRelativeTime, this.elapsedTime]), (0, operators_1.tap)(([_, cur]) => (oldRelativeTime = cur)))
+            .subscribe(this._tick$);
+    }
+    static get instance() {
+        if (!GgGlobalClock._instance) {
+            GgGlobalClock._instance = new GgGlobalClock();
+        }
+        return GgGlobalClock._instance;
+    }
+    get tick$() {
+        return this._tick$.pipe((0, operators_1.map)(([oldTime, newTime]) => [newTime, newTime - oldTime]));
+    }
+    get elapsedTime() {
+        return (typeof performance === 'undefined' ? Date : performance).now();
+    }
+    createChildClock(autoStart) {
+        return new clock_1.Clock(autoStart, this);
+    }
+}
+exports.GgGlobalClock = GgGlobalClock;

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

@@ -0,0 +1,83 @@
+import { GgEntity } from '../gg-entity';
+import { ITickListener } from '../interfaces/i-tick-listener';
+import { Observable, Subject } from 'rxjs';
+import { GgWorld } from '../../gg-world';
+export declare 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.
+ * The current value of the animation can be subscribed to using the `subscribeToValue` property.
+ * The animation function can be changed with `transitAnimationFunction` or `transitFromStaticState`.
+ */
+export declare class AnimationMixer<T> extends GgEntity implements ITickListener {
+    protected _animationFunction: AnimationFunction<T>;
+    protected _lerp: (a: T, b: T, t: number) => T;
+    readonly tick$: Subject<[number, number]>;
+    readonly tickOrder: number;
+    /**
+     * A subject that emits the current value of the animation on every tick.
+     */
+    protected readonly _value$: Subject<T>;
+    /**
+     * A subject that emits when the animator has been removed from the world.
+     */
+    protected readonly removed$: Subject<void>;
+    /**
+     * The current transition time reference `[elapsed, delta]` that interpolates between the old and new functions.
+     */
+    private _currentTransitionK;
+    /**
+     * The current transition subscription, which is null if no transition is currently active.
+     */
+    private _currentTransition;
+    /**
+     * A behavior subject that emits whether the animator is currently in a transition.
+     */
+    private _isInTransition$;
+    /**
+     * Gets an observable of the current value of the animation.
+     */
+    get value$(): Observable<T>;
+    /**
+     * Gets the current motion control function that determines the animation.
+     */
+    get animationFunction(): AnimationFunction<T>;
+    /**
+     * Sets the current motion control function that determines the animation.
+     * @param value The new motion control function.
+     */
+    set animationFunction(value: AnimationFunction<T>);
+    /**
+     * Gets a flag whether the animator is currently in a transition.
+     */
+    get isInTransition(): boolean;
+    /**
+     * Gets an observable that emits whether the animator is currently in a transition.
+     */
+    get isInTransition$(): Observable<boolean>;
+    protected get currentTransition(): ((a: [number, number]) => void) | null;
+    protected set currentTransition(value: ((a: [number, number]) => void) | null);
+    /**
+     * 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: AnimationFunction<T>, _lerp?: (a: T, b: T, t: number) => T);
+    /**
+     * Set output to static value and smoothly transit to new control function
+     * @param newFunc a new function
+     * @param transitionDuration a duration, after which new function will be fully controlling the output
+     * @param easing an easing function for transition
+     */
+    transitFromStaticState(state: T, newFunc: AnimationFunction<T>, transitionDuration: number, easing?: (t: number) => number): void;
+    /**
+     * Smoothly transit to new control function
+     * @param newFunc a new function
+     * @param transitionDuration a duration, after which new function will be fully controlling the output
+     * @param easing an easing function for transition
+     */
+    transitAnimationFunction(newFunc: AnimationFunction<T>, transitionDuration: number, easing?: (t: number) => number): void;
+    onSpawned(world: GgWorld<any, any>): void;
+    onRemoved(): void;
+    dispose(): void;
+}

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

@@ -0,0 +1,152 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AnimationMixer = void 0;
+const gg_entity_1 = require("../gg-entity");
+const rxjs_1 = require("rxjs");
+const operators_1 = require("rxjs/operators");
+/**
+ * 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.
+ * The current value of the animation can be subscribed to using the `subscribeToValue` property.
+ * The animation function can be changed with `transitAnimationFunction` or `transitFromStaticState`.
+ */
+class AnimationMixer extends gg_entity_1.GgEntity {
+    /**
+     * 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.tick$ = new rxjs_1.Subject();
+        this.tickOrder = 850;
+        /**
+         * A subject that emits the current value of the animation on every tick.
+         */
+        this._value$ = new rxjs_1.Subject();
+        /**
+         * A subject that emits when the animator has been removed from the world.
+         */
+        this.removed$ = new rxjs_1.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 rxjs_1.BehaviorSubject(false);
+    }
+    /**
+     * Gets an observable of the current value of the animation.
+     */
+    get value$() {
+        return this._value$.asObservable();
+    }
+    /**
+     * Gets the current motion control function that determines the animation.
+     */
+    get animationFunction() {
+        return this._animationFunction;
+    }
+    /**
+     * Sets the current motion control function that determines the animation.
+     * @param value The new motion control function.
+     */
+    set animationFunction(value) {
+        if (this.currentTransition) {
+            this.currentTransition = null;
+        }
+        this._animationFunction = value;
+    }
+    /**
+     * Gets a flag whether the animator is currently in a transition.
+     */
+    get isInTransition() {
+        return this._isInTransition$.getValue();
+    }
+    /**
+     * Gets an observable that emits whether the animator is currently in a transition.
+     */
+    get isInTransition$() {
+        return this._isInTransition$.pipe((0, rxjs_1.distinctUntilChanged)());
+    }
+    get currentTransition() {
+        return this._currentTransition;
+    }
+    set currentTransition(value) {
+        this._currentTransition = value;
+        this._isInTransition$.next(!!value);
+    }
+    /**
+     * Set output to static value and smoothly transit to new control function
+     * @param newFunc a new function
+     * @param transitionDuration a duration, after which new function will be fully controlling the output
+     * @param easing an easing function for transition
+     */
+    transitFromStaticState(state, newFunc, transitionDuration, easing = x => x) {
+        this.animationFunction = () => state;
+        return this.transitAnimationFunction(newFunc, transitionDuration, easing);
+    }
+    /**
+     * Smoothly transit to new control function
+     * @param newFunc a new function
+     * @param transitionDuration a duration, after which new function will be fully controlling the output
+     * @param easing an easing function for transition
+     */
+    transitAnimationFunction(newFunc, transitionDuration, easing = x => x) {
+        let oldAnimFunc;
+        if (this.currentTransition) {
+            // interrupt it by freezing K, so it will still work as binding, but do not animate further
+            this.currentTransition = null;
+            const oldTransitionAnimationFunction = this._animationFunction;
+            const oldTransitionLatestK = this._currentTransitionK;
+            oldAnimFunc = () => oldTransitionAnimationFunction(...oldTransitionLatestK);
+        }
+        else {
+            oldAnimFunc = this._animationFunction;
+        }
+        let k = 0;
+        this._animationFunction = (elapsed, delta) => this._lerp(oldAnimFunc(elapsed, delta), newFunc(elapsed, delta), k);
+        let startTime;
+        this.currentTransition = ([elapsed, delta]) => {
+            this._currentTransitionK = [elapsed, delta];
+            if (startTime === undefined) {
+                startTime = elapsed;
+            }
+            else {
+                k = (elapsed - startTime) / transitionDuration;
+                if (k >= 1) {
+                    k = 1;
+                    this.currentTransition = null;
+                    this._animationFunction = newFunc;
+                }
+                else {
+                    k = easing(k);
+                }
+            }
+        };
+    }
+    onSpawned(world) {
+        super.onSpawned(world);
+        this.tick$
+            .pipe((0, rxjs_1.takeUntil)(this.removed$), (0, operators_1.tap)(([elapsed, delta]) => this.currentTransition && this.currentTransition([elapsed, delta])), (0, operators_1.map)(([elapsed, delta]) => this._animationFunction(elapsed, delta)))
+            .subscribe(value => this._value$.next(value));
+    }
+    onRemoved() {
+        super.onRemoved();
+        this.removed$.next();
+    }
+    dispose() {
+        super.dispose();
+        this.tick$.complete();
+        this._value$.complete();
+    }
+}
+exports.AnimationMixer = AnimationMixer;

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

@@ -1,13 +1,16 @@
 import { GgWorld } from '../gg-world';
+import { Subject } from 'rxjs';
 export declare abstract class GgEntity {
-    get world(): GgWorld<any, any> | null;
     protected _world: GgWorld<any, any> | null;
+    get world(): GgWorld<any, any> | null;
     protected _name: string;
     get name(): string;
     set name(value: string);
     protected _children: GgEntity[];
     addChildren(...entities: GgEntity[]): void;
     removeChildren(entities: GgEntity[], dispose?: boolean): void;
+    protected _onSpawned$: Subject<void>;
+    protected _onRemoved$: Subject<void>;
     onSpawned(world: GgWorld<any, any>): void;
     onRemoved(): void;
     dispose(): void;

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

@@ -1,11 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.GgEntity = void 0;
+const rxjs_1 = require("rxjs");
 class GgEntity {
     constructor() {
         this._world = null;
         this._name = '';
         this._children = [];
+        this._onSpawned$ = new rxjs_1.Subject();
+        this._onRemoved$ = new rxjs_1.Subject();
     }
     get world() {
         return this._world;
@@ -37,6 +40,7 @@ class GgEntity {
         for (const c of this._children) {
             world.addEntity(c);
         }
+        this._onSpawned$.next();
     }
     onRemoved() {
         const world = this._world;
@@ -44,9 +48,12 @@ class GgEntity {
         for (const c of this._children) {
             world.removeEntity(c);
         }
+        this._onRemoved$.next();
     }
     // TODO add some flag to entity that it is disposed, and throw a normal error when trying to add such entity to world again
     dispose() {
+        this._onSpawned$.complete();
+        this._onRemoved$.complete();
         for (const c of this._children) {
             c.dispose();
         }

package/dist/base/entities/inline-controller.js

@@ -11,7 +11,6 @@ class InlineTickController extends gg_entity_1.GgEntity {
     }
     dispose() {
         super.dispose();
-        this.tick$.unsubscribe();
         this.tick$.complete();
     }
 }

package/dist/base/gg-viewport-manager.d.ts

@@ -1,5 +1,9 @@
 import { Subject } from 'rxjs';
 import { BaseGgRenderer } from './entities/base-gg-renderer';
+export declare type CanvasAppDescr = {
+    canvas: HTMLCanvasElement;
+    renderer?: BaseGgRenderer;
+};
 export declare class GgViewportManager {
     private static _instance;
     static get instance(): GgViewportManager;

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

@@ -3,13 +3,14 @@ import { ITickListener } from './entities/interfaces/i-tick-listener';
 import { GgPhysicsWorld } from './interfaces/gg-physics-world';
 import { GgVisualScene } from './interfaces/gg-visual-scene';
 import { KeyboardController } from './controllers/keyboard.controller';
+import { GgPositionableEntity } from './entities/gg-positionable-entity';
 export declare abstract class GgWorld<D, R, V extends GgVisualScene<D, R> = GgVisualScene<D, R>, P extends GgPhysicsWorld<D, R> = GgPhysicsWorld<D, R>> {
     readonly visualScene: V;
     readonly physicsWorld: P;
     protected readonly consoleEnabled: boolean;
-    private readonly animationFrameClock;
     private readonly worldClock;
     readonly keyboardController: KeyboardController;
+    get worldTime(): number;
     readonly children: GgEntity[];
     protected readonly tickListeners: ITickListener[];
     constructor(visualScene: V, physicsWorld: P, consoleEnabled?: boolean);
@@ -18,6 +19,7 @@ export declare abstract class GgWorld<D, R, V extends GgVisualScene<D, R> = GgVi
     pauseWorld(): void;
     resumeWorld(): void;
     dispose(): void;
+    abstract addPrimitiveRigidBody(descr: any, position?: D, rotation?: R): GgPositionableEntity<D, R>;
     addEntity(entity: GgEntity): void;
     removeEntity(entity: GgEntity, dispose?: boolean): void;
     protected commands: {

package/dist/base/gg-world.js

@@ -10,22 +10,20 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.GgWorld = void 0;
-const clock_1 = require("./clock");
 const i_tick_listener_1 = require("./entities/interfaces/i-tick-listener");
 const gg_static_1 = require("./gg-static");
 const keyboard_controller_1 = require("./controllers/keyboard.controller");
 const rxjs_1 = require("rxjs");
 const gg_console_ui_1 = require("./ui/gg-console.ui");
 const gg_debugger_ui_1 = require("./ui/gg-debugger.ui");
+const global_clock_1 = require("./clock/global-clock");
 class GgWorld {
     constructor(visualScene, physicsWorld, consoleEnabled = false) {
         this.visualScene = visualScene;
         this.physicsWorld = physicsWorld;
         this.consoleEnabled = consoleEnabled;
-        // inner clock, runs constantly
-        this.animationFrameClock = clock_1.Clock.animationFrameClock;
         // world clock, can be paused/resumed. Stops when disposing world
-        this.worldClock = new clock_1.Clock(this.animationFrameClock.tick$);
+        this.worldClock = global_clock_1.GgGlobalClock.instance.createChildClock(false);
         // TODO consider adding mouse controller
         this.keyboardController = new keyboard_controller_1.KeyboardController();
         this.children = [];
@@ -78,6 +76,9 @@ class GgWorld {
             }), 'args: [0 or 1]; turn on/off physics debug view. Default value is 0');
         }
     }
+    get worldTime() {
+        return this.worldClock.elapsedTime;
+    }
     init() {
         return __awaiter(this, void 0, void 0, function* () {
             yield Promise.all([this.physicsWorld.init(), this.visualScene.init()]);
@@ -103,7 +104,7 @@ class GgWorld {
         this.worldClock.pause();
     }
     resumeWorld() {
-        this.worldClock.pause();
+        this.worldClock.resume();
     }
     dispose() {
         this.worldClock.stop();

package/dist/base/math/matrix4.js

@@ -8,7 +8,7 @@ class Mtrx4 {
         let z = point3_1.Pnt3.sub(eye, target);
         if (point3_1.Pnt3.lenSq(z) === 0) {
             // same position
-            z.z = 1;
+            z = Object.assign(Object.assign({}, z), { z: 1 });
         }
         else {
             z = point3_1.Pnt3.norm(z);
@@ -17,10 +17,10 @@ class Mtrx4 {
         if (point3_1.Pnt3.lenSq(x) === 0) {
             // up and z are parallel
             if (Math.abs(up.z) === 1) {
-                z.x += 0.0001;
+                z = Object.assign(Object.assign({}, z), { x: z.x + 0.0001 });
             }
             else {
-                z.z += 0.0001;
+                z = Object.assign(Object.assign({}, z), { z: z.z + 0.0001 });
             }
             z = point3_1.Pnt3.norm(z);
             x = point3_1.Pnt3.cross(up, z);

package/dist/base/math/point2.js

@@ -4,7 +4,7 @@ exports.Pnt2 = void 0;
 class Pnt2 {
     /** clone point */
     static clone(p) {
-        return Object.assign({}, p);
+        return { x: p.x, y: p.y };
     }
     /** add point b to point a */
     static add(a, b) {

package/dist/base/math/point3.js

@@ -5,7 +5,7 @@ const quaternion_1 = require("./quaternion");
 class Pnt3 {
     /** clone point */
     static clone(p) {
-        return Object.assign({}, p);
+        return { x: p.x, y: p.y, z: p.z };
     }
     /** add point b to point a */
     static add(a, b) {