@gg-web-engine/core 0.0.3 → 0.0.5

package/dist/3d/inputs/car-keyboard.input.js

@@ -0,0 +1,100 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CarKeyboardInput = void 0;
+const rxjs_1 = require("rxjs");
+const operators_1 = require("rxjs/operators");
+const input_1 = require("../../base/inputs/input");
+const direction_keyboard_input_1 = require("../../base/inputs/direction.keyboard-input");
+// TODO pass as settings
+// TODO smooth y?
+const TICKER_INTERVAL = 16;
+const TICKER_MAX_STEPS = 10;
+class CarKeyboardInput extends input_1.Input {
+    constructor(keyboard, car, options = { keymap: 'arrows', gearUpDownKeys: ['KeyA', 'KeyZ'] }) {
+        super();
+        this.keyboard = keyboard;
+        this.options = options;
+        // emits values -1 - 1; -1 = full turn left; 1 = full turn right
+        this.x$ = new rxjs_1.BehaviorSubject(0);
+        // emits values -1 - 1; -1 = full brake; 1 = full acceleration
+        this.y$ = new rxjs_1.BehaviorSubject(0);
+        this.lastX = 0;
+        this.car$ = new rxjs_1.BehaviorSubject(null);
+        this.switchingGearsEnabled = true;
+        this.pairTickerPipe = (0, rxjs_1.pipe)((0, operators_1.startWith)(0), (0, operators_1.pairwise)(), (0, operators_1.map)(([beforeValue, afterValue]) => [this.lastX, afterValue]), (0, operators_1.switchMap)(([beforeValue, afterValue]) => (0, rxjs_1.interval)(TICKER_INTERVAL).pipe((0, operators_1.take)(TICKER_MAX_STEPS), (0, operators_1.map)(count => ++count), (0, operators_1.map)(count => beforeValue * ((TICKER_MAX_STEPS - count) / TICKER_MAX_STEPS) + afterValue * (count / TICKER_MAX_STEPS)), (0, operators_1.tap)(x => {
+            this.lastX = x;
+        }))));
+        this.car$.next(car);
+        this.directionsInput = new direction_keyboard_input_1.DirectionKeyboardInput(keyboard, options.keymap);
+    }
+    set car(value) {
+        this.car$.next(value);
+    }
+    get car() {
+        return this.car$.getValue();
+    }
+    startInternal() {
+        return __awaiter(this, void 0, void 0, function* () {
+            let moveDirection = {};
+            this.keyboard
+                .bind(this.options.gearUpDownKeys[0])
+                .pipe((0, rxjs_1.takeUntil)(this.stop$), (0, rxjs_1.filter)(x => this.switchingGearsEnabled && !!x))
+                .subscribe(() => {
+                if (this.car$.getValue() &&
+                    (!this.car$.getValue().carProperties.transmission.isAuto || this.car$.getValue().gear <= 0)) {
+                    this.car$.getValue().gear++;
+                }
+            });
+            this.keyboard
+                .bind(this.options.gearUpDownKeys[1])
+                .pipe((0, rxjs_1.takeUntil)(this.stop$), (0, rxjs_1.filter)(x => this.switchingGearsEnabled && !!x))
+                .subscribe(() => {
+                if (this.car$.getValue().carProperties.transmission.isAuto && this.car.gear > 1) {
+                    this.car$.getValue().gear = 0;
+                }
+                else {
+                    this.car$.getValue().gear--;
+                }
+            });
+            this.directionsInput.output$.pipe((0, rxjs_1.takeUntil)(this.stop$)).subscribe(d => {
+                moveDirection = d;
+            });
+            this.car$
+                .pipe((0, rxjs_1.takeUntil)(this.stop$), (0, operators_1.switchMap)(c => c.tick$), (0, rxjs_1.takeUntil)(this.stop$), (0, operators_1.map)(() => {
+                const direction = [0, 0];
+                if (moveDirection.leftRight !== undefined)
+                    direction[0] = moveDirection.leftRight ? -1 : 1;
+                if (moveDirection.upDown !== undefined)
+                    direction[1] = moveDirection.upDown ? 1 : -1;
+                return direction;
+            }))
+                .subscribe(([x, y]) => {
+                this.x$.next(x);
+                this.y$.next(y);
+            });
+            (0, rxjs_1.combineLatest)([
+                this.x$.pipe((0, rxjs_1.takeUntil)(this.stop$), (0, operators_1.distinctUntilChanged)(), this.pairTickerPipe),
+                this.y$.pipe((0, rxjs_1.takeUntil)(this.stop$), (0, operators_1.distinctUntilChanged)()),
+            ]).subscribe(([x, y]) => {
+                this.car$.getValue().setXAxisControlValue(x);
+                this.car$.getValue().setYAxisControlValue(y);
+            });
+            yield this.directionsInput.start();
+        });
+    }
+    stopInternal() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.directionsInput.stop();
+        });
+    }
+}
+exports.CarKeyboardInput = CarKeyboardInput;

package/dist/3d/inputs/free-camera.input.d.ts

@@ -0,0 +1,22 @@
+import { Input } from '../../base/inputs/input';
+import { MouseControllerOptions, MouseInput } from '../../base/inputs/mouse.input';
+import { Gg3dCameraEntity } from '../entities/gg-3d-camera.entity';
+import { KeyboardInput } from '../../base/inputs/keyboard.input';
+import { DirectionKeyboardInput, DirectionKeyboardKeymap } from '../../base/inputs/direction.keyboard-input';
+export declare type FreeCameraControllerOptions = {
+    keymap: DirectionKeyboardKeymap;
+    movementOptions: {
+        speed: number;
+    };
+    mouseOptions: MouseControllerOptions;
+};
+export declare class FreeCameraInput extends Input<[], [unlockPointer?: boolean]> {
+    protected readonly keyboard: KeyboardInput;
+    protected readonly camera: Gg3dCameraEntity;
+    protected readonly options: FreeCameraControllerOptions;
+    protected readonly mouseInput: MouseInput;
+    protected readonly directionsInput: DirectionKeyboardInput;
+    constructor(keyboard: KeyboardInput, camera: Gg3dCameraEntity, options?: FreeCameraControllerOptions);
+    protected startInternal(): Promise<void>;
+    protected stopInternal(unlockPointer?: boolean): Promise<void>;
+}

package/dist/3d/inputs/free-camera.input.js

@@ -0,0 +1,80 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FreeCameraInput = void 0;
+const input_1 = require("../../base/inputs/input");
+const rxjs_1 = require("rxjs");
+const mouse_input_1 = require("../../base/inputs/mouse.input");
+const point3_1 = require("../../base/math/point3");
+const point2_1 = require("../../base/math/point2");
+const quaternion_1 = require("../../base/math/quaternion");
+const direction_keyboard_input_1 = require("../../base/inputs/direction.keyboard-input");
+class FreeCameraInput extends input_1.Input {
+    constructor(keyboard, camera, options = {
+        keymap: 'wasd',
+        movementOptions: { speed: 0.5 },
+        mouseOptions: {},
+    }) {
+        super();
+        this.keyboard = keyboard;
+        this.camera = camera;
+        this.options = options;
+        this.mouseInput = new mouse_input_1.MouseInput(options.mouseOptions);
+        this.directionsInput = new direction_keyboard_input_1.DirectionKeyboardInput(keyboard, options.keymap);
+    }
+    startInternal() {
+        return __awaiter(this, void 0, void 0, function* () {
+            let controls = { direction: {}, rest: [] };
+            const keys = ['KeyE', 'KeyQ'];
+            if (this.camera.object3D.supportsFov) {
+                keys.push('KeyZ', 'KeyC');
+            }
+            this.directionsInput.output$.pipe((0, rxjs_1.takeUntil)(this.stop$)).subscribe(d => {
+                controls.direction = d;
+            });
+            (0, rxjs_1.combineLatest)(keys.map(c => this.keyboard.bind(c)))
+                .pipe((0, rxjs_1.takeUntil)(this.stop$))
+                .subscribe((d) => {
+                controls.rest = d;
+            });
+            let rotationDelta = { x: 0, y: 0 };
+            this.mouseInput.delta$.pipe((0, rxjs_1.takeUntil)(this.stop$)).subscribe(delta => {
+                rotationDelta = point2_1.Pnt2.add(rotationDelta, delta);
+            });
+            this.camera.tick$.pipe((0, rxjs_1.takeUntil)(this.stop$)).subscribe(() => {
+                let translateVector = { x: 0, y: 0, z: 0 };
+                const [u, d, zo, zi] = controls.rest;
+                if (controls.direction.upDown !== undefined)
+                    translateVector.z = controls.direction.upDown ? -1 : 1;
+                if (controls.direction.leftRight !== undefined)
+                    translateVector.x = controls.direction.leftRight ? -1 : 1;
+                if (u != d)
+                    translateVector.y = d ? -1 : 1;
+                if (zo != zi)
+                    this.camera.object3D.fov += zo ? 1 : -1;
+                this.camera.position = point3_1.Pnt3.add(this.camera.position, point3_1.Pnt3.rot(point3_1.Pnt3.scalarMult(point3_1.Pnt3.norm(translateVector), this.options.movementOptions.speed), this.camera.rotation));
+                if (rotationDelta.x != 0 || rotationDelta.y != 0) {
+                    this.camera.rotation = quaternion_1.Qtrn.combineRotations(quaternion_1.Qtrn.fromAngle({ x: 0, y: 0, z: 1 }, -rotationDelta.x / 300), this.camera.rotation, quaternion_1.Qtrn.fromAngle({ x: 1, y: 0, z: 0 }, -rotationDelta.y / 300));
+                    rotationDelta = { x: 0, y: 0 };
+                }
+            });
+            yield this.mouseInput.start();
+            yield this.directionsInput.start();
+        });
+    }
+    stopInternal(unlockPointer = true) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.mouseInput.stop(unlockPointer);
+            yield this.directionsInput.stop();
+        });
+    }
+}
+exports.FreeCameraInput = FreeCameraInput;

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

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

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

@@ -3,7 +3,7 @@ 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");
+const pausable_clock_1 = require("./pausable-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
@@ -30,7 +30,7 @@ class GgGlobalClock {
         return (typeof performance === 'undefined' ? Date : performance).now();
     }
     createChildClock(autoStart) {
-        return new clock_1.Clock(autoStart, this);
+        return new pausable_clock_1.PausableClock(autoStart, this);
     }
 }
 exports.GgGlobalClock = GgGlobalClock;

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

@@ -0,0 +1,7 @@
+import { Observable } from 'rxjs';
+import { PausableClock } from './pausable-clock';
+export interface IClock {
+    get tick$(): Observable<[number, number]>;
+    get elapsedTime(): number;
+    createChildClock(autoStart: boolean): PausableClock;
+}

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

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1,25 @@
+import { Observable } from 'rxjs';
+import { IClock } from './i-clock';
+/**
+ * A class, providing ability to track time, fire ticks, provide time elapsed + tick delta with ability to suspend/resume it.
+ */
+export declare class PausableClock implements IClock {
+    protected readonly parentClock: IClock;
+    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?: IClock);
+    createChildClock(autoStart: boolean): PausableClock;
+    start(): void;
+    stop(): void;
+    pause(): void;
+    resume(): void;
+    protected startListeningTicks(): void;
+    protected stopListeningTicks(): void;
+}

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

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PausableClock = 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 PausableClock {
+    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 PausableClock(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.PausableClock = PausableClock;

package/dist/base/data-structures/graph.d.ts

@@ -1,5 +1,21 @@
 export declare class Graph<T> {
-    static fromArray<T>(array: T[]): Graph<T>;
+    /**
+     * 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.
+     * @param array The array of elements to create the graph from.
+     * @param closed An optional boolean indicating whether the graph is closed, meaning that the last node is adjacent to the first node.
+     * @returns A new Graph instance created from the array.
+     * @typeparam T The type of elements in the array and nodes in the graph.
+     */
+    static fromArray<T>(array: T[], closed?: boolean): Graph<T>;
+    /**
+     * Creates a new Graph instance from a two-dimensional square grid of elements, where each element in the grid is a node in the graph.
+     * The top-left element of the grid is used as the root node of the graph.
+     * The nodes in the graph are created in the same order as the elements in the grid, from left to right and then from top to bottom.
+     * @param grid The two-dimensional square grid of elements to create the graph from.
+     * @returns A new Graph instance created from the square grid.
+     * @typeparam T The type of elements in the square grid and nodes in the graph.
+     */
     static fromSquareGrid<T>(grid: T[][]): Graph<T>;
     data: T;
     private adjacent;

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

@@ -6,7 +6,15 @@ class Graph {
         this.data = data;
         this.adjacent = new Set();
     }
-    static fromArray(array) {
+    /**
+     * 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.
+     * @param array The array of elements to create the graph from.
+     * @param closed An optional boolean indicating whether the graph is closed, meaning that the last node is adjacent to the first node.
+     * @returns A new Graph instance created from the array.
+     * @typeparam T The type of elements in the array and nodes in the graph.
+     */
+    static fromArray(array, closed = false) {
         const root = new Graph(array[0]);
         let tail = root;
         for (let i = 1; i < array.length; i++) {
@@ -14,8 +22,19 @@ class Graph {
             tail.addAdjacent(newTail);
             tail = newTail;
         }
+        if (closed) {
+            tail.addAdjacent(root);
+        }
         return root;
     }
+    /**
+     * Creates a new Graph instance from a two-dimensional square grid of elements, where each element in the grid is a node in the graph.
+     * The top-left element of the grid is used as the root node of the graph.
+     * The nodes in the graph are created in the same order as the elements in the grid, from left to right and then from top to bottom.
+     * @param grid The two-dimensional square grid of elements to create the graph from.
+     * @returns A new Graph instance created from the square grid.
+     * @typeparam T The type of elements in the square grid and nodes in the graph.
+     */
     static fromSquareGrid(grid) {
         const nodes = grid.map(sgrid => sgrid.map(item => new Graph(item)));
         // bind them

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

@@ -1,7 +1,6 @@
-import { ITickListener } from './interfaces/i-tick-listener';
-import { Subject, Subscription } from 'rxjs';
-import { GgEntity } from './gg-entity';
+import { GgEntity, GGTickOrder } from './gg-entity';
 import { Point2 } from '../models/points';
+import { GgWorld } from '../gg-world';
 export declare type RendererOptions = {
     transparent: boolean;
     background: number;
@@ -9,20 +8,13 @@ export declare type RendererOptions = {
     forceResolution?: number;
     antialias: boolean;
 };
-export declare abstract class BaseGgRenderer extends GgEntity implements ITickListener {
-    protected _permanentRenderMethods: Map<number, Function>;
-    protected _singularRenderMethods: Map<number, Function>;
-    private initialized;
-    readonly tick$: Subject<[number, number]>;
-    readonly tickOrder = 1000;
-    protected tickListener: Subscription | null;
+export declare abstract class BaseGgRenderer extends GgEntity {
+    protected readonly canvas?: HTMLCanvasElement | undefined;
+    readonly tickOrder = GGTickOrder.RENDERING;
     readonly rendererOptions: RendererOptions;
-    protected constructor(canvas?: HTMLCanvasElement, options?: Partial<RendererOptions>);
-    get isActive(): boolean;
-    activate(): void;
-    deactivate(): void;
-    init(): void;
+    protected constructor(canvas?: HTMLCanvasElement | undefined, options?: Partial<RendererOptions>);
     abstract render(): void;
     abstract resize(newSize: Point2): void;
-    abstract dispose(): void;
+    onSpawned(world: GgWorld<any, any>): void;
+    onRemoved(): void;
 }

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

@@ -1,49 +1,33 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BaseGgRenderer = void 0;
-const rxjs_1 = require("rxjs");
 const gg_entity_1 = require("./gg-entity");
 const gg_viewport_manager_1 = require("../gg-viewport-manager");
 class BaseGgRenderer extends gg_entity_1.GgEntity {
     constructor(canvas, options = {}) {
         super();
-        this.initialized = false;
-        this.tickOrder = 1000;
-        this.tickListener = null;
+        this.canvas = canvas;
+        this.tickOrder = gg_entity_1.GGTickOrder.RENDERING;
         this.rendererOptions = Object.assign({ transparent: false, background: 0x000000, antialias: true }, (options || {}));
-        this._permanentRenderMethods = new Map();
-        this._singularRenderMethods = new Map();
-        this.tick$ = new rxjs_1.Subject();
-        if (canvas) {
-            setTimeout(() => {
-                gg_viewport_manager_1.GgViewportManager.instance.assignRendererToCanvas(this, canvas).then();
-            }, 0);
-        }
-    }
-    get isActive() {
-        return !!this.tickListener;
-    }
-    activate() {
-        if (this.isActive) {
-            return;
-        }
-        if (!this.initialized) {
-            this.init();
-        }
-        this.tickListener = this.tick$.subscribe(() => {
+        this.tick$.subscribe(() => {
             this.render();
         });
     }
-    deactivate() {
-        var _a;
-        if (!this.isActive) {
-            return;
+    onSpawned(world) {
+        super.onSpawned(world);
+        if (this.canvas) {
+            setTimeout(() => {
+                gg_viewport_manager_1.GgViewportManager.instance.assignRendererToCanvas(this, this.canvas).then();
+            }, 0);
         }
-        (_a = this.tickListener) === null || _a === void 0 ? void 0 : _a.unsubscribe();
-        this.tickListener = null;
     }
-    init() {
-        this.initialized = true;
+    onRemoved() {
+        super.onRemoved();
+        if (this.canvas) {
+            setTimeout(() => {
+                gg_viewport_manager_1.GgViewportManager.instance.deregisterCanvas(this.canvas).then();
+            }, 0);
+        }
     }
 }
 exports.BaseGgRenderer = BaseGgRenderer;

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

@@ -1,5 +1,4 @@
 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;
@@ -9,19 +8,14 @@ export declare type AnimationFunction<T> = (elapsed: number, delta: number) => T
  * 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 {
+export declare class AnimationMixer<T> extends GgEntity {
     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.
      */
@@ -78,6 +72,5 @@ export declare class AnimationMixer<T> extends GgEntity implements ITickListener
      */
     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

@@ -20,16 +20,11 @@ class AnimationMixer extends gg_entity_1.GgEntity {
         super();
         this._animationFunction = _animationFunction;
         this._lerp = _lerp;
-        this.tick$ = new rxjs_1.Subject();
-        this.tickOrder = 850;
+        this.tickOrder = gg_entity_1.GGTickOrder.ANIMATION_MIXERS;
         /**
          * 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.
          */
@@ -136,13 +131,9 @@ class AnimationMixer extends gg_entity_1.GgEntity {
     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)))
+            .pipe((0, rxjs_1.takeUntil)(this._onRemoved$), (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();

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

@@ -1,11 +1,41 @@
 import { GgWorld } from '../gg-world';
 import { Subject } from 'rxjs';
+/**
+ * Engine's default tick orders: the less value, the earlier tick will be run.
+ */
+export declare enum GGTickOrder {
+    INPUT_CONTROLLERS = 0,
+    PHYSICS_SIMULATION = 200,
+    OBJECTS_BINDING = 400,
+    ANIMATION_MIXERS = 600,
+    CONTROLLERS = 800,
+    RENDERING = 1000,
+    POST_RENDERING = 1200
+}
 export declare abstract class GgEntity {
+    private static default_name_counter;
+    /**
+     * will receive [elapsed time, delta] of each world clock tick
+     */
+    readonly tick$: Subject<[number, number]>;
+    /**
+     * the priority of ticker: the less value, the earlier tick will be run.
+     */
+    abstract readonly tickOrder: GGTickOrder | number;
+    /**
+     * a world reference, where this entity was added to
+     */
     protected _world: GgWorld<any, any> | null;
     get world(): GgWorld<any, any> | null;
     protected _name: string;
     get name(): string;
     set name(value: string);
+    /**
+     * The flag whether entity should listen to ticks. If set to false, ticks will not be propagated to this entity
+     * */
+    protected _active: boolean;
+    get active(): boolean;
+    set active(value: boolean);
     protected _children: GgEntity[];
     addChildren(...entities: GgEntity[]): void;
     removeChildren(entities: GgEntity[], dispose?: boolean): void;