@gg-web-engine/core 0.0.1

package/dist/3d/entities/gg-positionable-3d-entity.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GgPositionable3dEntity = void 0;
+const gg_positionable_entity_1 = require("../../base/entities/gg-positionable-entity");
+const operators_1 = require("rxjs/operators");
+const quaternion_1 = require("../../base/math/quaternion");
+class GgPositionable3dEntity extends gg_positionable_entity_1.GgPositionableEntity {
+    getDefaultPosition() {
+        return { x: 0, y: 0, z: 0 };
+    }
+    getDefaultRotation() {
+        return { x: 0, y: 0, z: 0, w: 1 };
+    }
+    getDefaultScale() {
+        return { x: 1, y: 1, z: 1 };
+    }
+    get euler$() {
+        return this._rotation$.pipe((0, operators_1.map)(q => quaternion_1.Qtrn.toEuler(q)));
+    }
+    get euler() {
+        return quaternion_1.Qtrn.toEuler(this._rotation$.getValue());
+    }
+    set euler(value) {
+        this._rotation$.next(quaternion_1.Qtrn.fromEuler(value));
+    }
+}
+exports.GgPositionable3dEntity = GgPositionable3dEntity;

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

@@ -0,0 +1,21 @@
+import { BodyShape3DDescriptor, Shape3DDescriptor } from './models/shapes';
+import { Point3, Point4 } from '../base/models/points';
+import { IGg3dBody, IGg3dObject, IGg3dTrigger } from './interfaces';
+export declare abstract class IGg3dObjectFactory<T extends IGg3dObject = IGg3dObject> {
+    abstract createPrimitive(descriptor: Shape3DDescriptor, material?: any): T;
+    createBox(dimensions: Point3, material?: any): T;
+    createCapsule(radius: number, centersDistance: number, material?: any): T;
+    createCylinder(radius: number, height: number, material?: any): T;
+    createCone(radius: number, height: number, material?: any): T;
+    createSphere(radius: number): T;
+}
+export interface IGg3dBodyFactory<T extends IGg3dBody = IGg3dBody, K extends IGg3dTrigger = IGg3dTrigger> {
+    createRigidBody(descriptor: BodyShape3DDescriptor, transform?: {
+        position?: Point3;
+        rotation?: Point4;
+    }): T;
+    createTrigger(descriptor: Shape3DDescriptor, transform?: {
+        position?: Point3;
+        rotation?: Point4;
+    }): K;
+}

package/dist/3d/factories.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IGg3dObjectFactory = void 0;
+class IGg3dObjectFactory {
+    // shortcuts
+    createBox(dimensions, material) {
+        return this.createPrimitive({ shape: 'BOX', dimensions }, material);
+    }
+    createCapsule(radius, centersDistance, material) {
+        return this.createPrimitive({ shape: 'CAPSULE', radius, centersDistance }, material);
+    }
+    createCylinder(radius, height, material) {
+        return this.createPrimitive({ shape: 'CYLINDER', radius, height }, material);
+    }
+    createCone(radius, height, material) {
+        return this.createPrimitive({ shape: 'CONE', radius, height }, material);
+    }
+    createSphere(radius) {
+        return this.createPrimitive({ shape: 'SPHERE', radius });
+    }
+}
+exports.IGg3dObjectFactory = IGg3dObjectFactory;

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

@@ -0,0 +1,11 @@
+import { GgWorld } from '../base/gg-world';
+import { Point3, Point4 } from '../base/models/points';
+import { IGg3dPhysicsWorld, IGg3dVisualScene } from './interfaces';
+import { Gg3dLoader } from './loader';
+export declare class Gg3dWorld<V extends IGg3dVisualScene = IGg3dVisualScene, P extends IGg3dPhysicsWorld = IGg3dPhysicsWorld> extends GgWorld<Point3, Point4, V, P> {
+    readonly visualScene: V;
+    readonly physicsWorld: P;
+    protected readonly consoleEnabled: boolean;
+    readonly loader: Gg3dLoader;
+    constructor(visualScene: V, physicsWorld: P, consoleEnabled?: boolean);
+}

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

@@ -0,0 +1,36 @@
+"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.Gg3dWorld = void 0;
+const gg_world_1 = require("../base/gg-world");
+const loader_1 = require("./loader");
+class Gg3dWorld extends gg_world_1.GgWorld {
+    constructor(visualScene, physicsWorld, consoleEnabled = false) {
+        super(visualScene, physicsWorld, consoleEnabled);
+        this.visualScene = visualScene;
+        this.physicsWorld = physicsWorld;
+        this.consoleEnabled = consoleEnabled;
+        this.loader = new loader_1.Gg3dLoader(this);
+        if (consoleEnabled) {
+            this.registerConsoleCommand('ph_gravity', (...args) => __awaiter(this, void 0, void 0, function* () {
+                if (args.length == 1) {
+                    args = ['0', '0', '' + -+args[0]]; // mean -Z axis
+                }
+                if (args.length > 0) {
+                    this.physicsWorld.gravity = { x: +args[0], y: +args[1], z: +args[2] };
+                }
+                return JSON.stringify(this.physicsWorld.gravity);
+            }), 'args: [float] or [float float float]; change 3D world gravity vector. 1 argument means ' +
+                '{x: 0, y: 0, z: -value}, 3 arguments set the whole vector. Default value is "9.82" or "0 0 -9.82"');
+        }
+    }
+}
+exports.Gg3dWorld = Gg3dWorld;

package/dist/3d/interfaces.d.ts

@@ -0,0 +1,65 @@
+import { GgBody } from '../base/interfaces/gg-body';
+import { Point3, Point4 } from '../base/models/points';
+import { GgObject } from '../base/interfaces/gg-object';
+import { GgPhysicsWorld } from '../base/interfaces/gg-physics-world';
+import { GgVisualScene } from '../base/interfaces/gg-visual-scene';
+import { GgMeta } from './models/gg-meta';
+import { BaseGgRenderer } from '../base/entities/base-gg-renderer';
+import { Gg3dCameraEntity } from './entities/gg-3d-camera.entity';
+import { GgWorld } from '../base/gg-world';
+import { SuspensionOptions, WheelOptions } from './entities/gg-3d-raycast-vehicle.entity';
+import { GgTrigger } from '../base/interfaces/gg-trigger';
+import { Observable } from 'rxjs';
+import { GgPositionable3dEntity } from './entities/gg-positionable-3d-entity';
+import { IGg3dBodyFactory, IGg3dObjectFactory } from './factories';
+export interface IGg3dPhysicsWorld extends GgPhysicsWorld<Point3, Point4> {
+    readonly factory: IGg3dBodyFactory;
+    readonly loader: IGg3dBodyLoader;
+}
+export declare abstract class Gg3dRenderer extends BaseGgRenderer {
+    abstract readonly camera: Gg3dCameraEntity;
+    onSpawned(world: GgWorld<any, any>): void;
+    onRemoved(): void;
+}
+export interface IGg3dBody extends GgBody<Point3, Point4> {
+}
+export interface IGg3dTrigger extends GgTrigger<Point3, Point4> {
+    get onEntityEntered(): Observable<GgPositionable3dEntity>;
+    get onEntityLeft(): Observable<GgPositionable3dEntity | null>;
+}
+export interface IGg3dRaycastVehicle extends IGg3dBody {
+    /** Return speed in m/s, calculated by car itself (which should be shown on the speedometer) */
+    get wheelSpeed(): number;
+    addWheel(options: WheelOptions, suspensionOptions: SuspensionOptions): void;
+    /** Set steering value for wheel. The unit of steering is radian */
+    setSteering(wheelIndex: number, steering: number): void;
+    /** Apply force to wheel. Units? */
+    applyEngineForce(wheelIndex: number, force: number): void;
+    /** Apply brake force to wheel. Units? */
+    applyBrake(wheelIndex: number, force: number): void;
+    isWheelTouchesGround(wheelIndex: number): boolean;
+    getWheelTransform(wheelIndex: number): {
+        position: Point3;
+        rotation: Point4;
+    };
+    resetSuspension(): void;
+}
+export declare abstract class IGg3dBodyLoader {
+    protected readonly world: IGg3dPhysicsWorld;
+    protected constructor(world: IGg3dPhysicsWorld);
+    loadFromGgGlb(glbFile: ArrayBuffer, meta: GgMeta): Promise<IGg3dBody[]>;
+}
+export interface IGg3dVisualScene extends GgVisualScene<Point3, Point4> {
+    readonly factory: IGg3dObjectFactory;
+    readonly loader: IGg3dObjectLoader;
+}
+export interface IGg3dObject extends GgObject<Point3, Point4> {
+}
+export interface IGg3dCamera extends IGg3dObject {
+    get supportsFov(): boolean;
+    get fov(): number;
+    set fov(f: number);
+}
+export interface IGg3dObjectLoader {
+    loadFromGgGlb(glbFile: ArrayBuffer, meta: GgMeta): Promise<IGg3dObject | null>;
+}

package/dist/3d/interfaces.js

@@ -0,0 +1,40 @@
+"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.IGg3dBodyLoader = exports.Gg3dRenderer = void 0;
+const base_gg_renderer_1 = require("../base/entities/base-gg-renderer");
+class Gg3dRenderer extends base_gg_renderer_1.BaseGgRenderer {
+    onSpawned(world) {
+        super.onSpawned(world);
+        world.addEntity(this.camera);
+    }
+    onRemoved() {
+        var _a;
+        super.onRemoved();
+        (_a = this.world) === null || _a === void 0 ? void 0 : _a.removeEntity(this.camera);
+    }
+}
+exports.Gg3dRenderer = Gg3dRenderer;
+class IGg3dBodyLoader {
+    constructor(world) {
+        this.world = world;
+    }
+    loadFromGgGlb(glbFile, meta) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return ((meta === null || meta === void 0 ? void 0 : meta.rigidBodies) || []).map(d => {
+                const body = this.world.factory.createRigidBody({ shape: d.shape, body: d.body }, { position: d.position, rotation: d.rotation });
+                body.name = d.name;
+                return body;
+            });
+        });
+    }
+}
+exports.IGg3dBodyLoader = IGg3dBodyLoader;

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

@@ -0,0 +1,40 @@
+import { Gg3dWorld } from './gg-3d-world';
+import { GgMeta } from './models/gg-meta';
+import { Gg3dEntity } from './entities/gg-3d-entity';
+import { Point3, Point4 } from '../base/models/points';
+import { IGg3dBody, IGg3dObject } from './interfaces';
+export declare enum CachingStrategy {
+    Nothing = 0,
+    Files = 1,
+    Entities = 2
+}
+export declare type LoadOptions = {
+    cachingStrategy: CachingStrategy;
+    position: Point3;
+    rotation: Point4;
+    loadProps: boolean;
+    propsPath?: string;
+};
+export declare type LoadResourcesResult = {
+    resources: {
+        object3D: IGg3dObject | null;
+        body: IGg3dBody | null;
+    }[];
+    meta: GgMeta;
+};
+export declare type LoadResult = {
+    entities: Gg3dEntity[];
+    meta: GgMeta;
+};
+export declare type LoadResultWithProps = LoadResult & {
+    props?: LoadResult[];
+};
+export declare class Gg3dLoader {
+    protected readonly world: Gg3dWorld;
+    readonly filesCache: Map<string, [ArrayBuffer, GgMeta] | Promise<[ArrayBuffer, GgMeta]>>;
+    readonly loadResultCache: Map<string, LoadResourcesResult | Promise<LoadResourcesResult>>;
+    constructor(world: Gg3dWorld);
+    loadGgGlbFiles(path: string, useCache?: boolean): Promise<[ArrayBuffer, GgMeta]>;
+    loadGgGlbResources(path: string, cachingStrategy?: CachingStrategy): Promise<LoadResourcesResult>;
+    loadGgGlb(path: string, options?: Partial<LoadOptions>): Promise<LoadResultWithProps>;
+}

package/dist/3d/loader.js

@@ -0,0 +1,129 @@
+"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.Gg3dLoader = exports.CachingStrategy = void 0;
+const gg_3d_entity_1 = require("./entities/gg-3d-entity");
+const point3_1 = require("../base/math/point3");
+const quaternion_1 = require("../base/math/quaternion");
+var CachingStrategy;
+(function (CachingStrategy) {
+    CachingStrategy[CachingStrategy["Nothing"] = 0] = "Nothing";
+    CachingStrategy[CachingStrategy["Files"] = 1] = "Files";
+    CachingStrategy[CachingStrategy["Entities"] = 2] = "Entities";
+})(CachingStrategy = exports.CachingStrategy || (exports.CachingStrategy = {}));
+const defaultLoadOptions = {
+    cachingStrategy: CachingStrategy.Nothing,
+    position: { x: 0, y: 0, z: 0 },
+    rotation: { x: 0, y: 0, z: 0, w: 1 },
+    loadProps: true,
+};
+const cloneLoadResourcesResult = (loadResult) => ({
+    meta: loadResult.meta,
+    resources: loadResult.resources.map(({ object3D, body }) => ({
+        object3D: object3D && object3D.clone(),
+        body: body && body.clone(),
+    })),
+});
+class Gg3dLoader {
+    constructor(world) {
+        this.world = world;
+        this.filesCache = new Map();
+        this.loadResultCache = new Map();
+    }
+    loadGgGlbFiles(path, useCache = false) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (useCache && this.filesCache.has(path)) {
+                return this.filesCache.get(path);
+            }
+            const loadPromise = Promise.all([
+                fetch(`${path}.glb`).then(r => r.arrayBuffer()),
+                fetch(`${path}.meta`)
+                    .then(r => r.text())
+                    .then(r => JSON.parse(r)),
+            ]);
+            if (useCache) {
+                this.filesCache.set(path, loadPromise);
+            }
+            const result = yield loadPromise;
+            if (useCache) {
+                this.filesCache.set(path, result);
+            }
+            return result;
+        });
+    }
+    loadGgGlbResources(path, cachingStrategy = CachingStrategy.Nothing) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (cachingStrategy == CachingStrategy.Entities && this.loadResultCache.has(path)) {
+                const cached = this.loadResultCache.get(path);
+                const cachedResult = cached instanceof Promise ? yield cached : cached;
+                return cloneLoadResourcesResult(cachedResult);
+            }
+            const [glb, meta] = yield this.loadGgGlbFiles(path, cachingStrategy == CachingStrategy.Files);
+            if (!glb) {
+                throw new Error('GLB not found');
+            }
+            const [object, bodies] = yield Promise.all([
+                this.world.visualScene.loader.loadFromGgGlb(glb, meta),
+                this.world.physicsWorld.loader.loadFromGgGlb(glb, meta),
+            ]);
+            const result = { resources: [], meta };
+            if (!object) {
+                return result;
+            }
+            if (bodies.length == 0) {
+                result.resources.push({ object3D: object, body: null });
+            }
+            else if (bodies.length == 1) {
+                result.resources.push({ object3D: object, body: bodies[0] });
+            }
+            else {
+                for (const body of bodies) {
+                    result.resources.push({ object3D: object.popChild(body.name), body });
+                }
+                if (!object.isEmpty()) {
+                    result.resources.push({ object3D: object, body: null });
+                }
+            }
+            if (cachingStrategy == CachingStrategy.Entities) {
+                this.loadResultCache.set(path, cloneLoadResourcesResult(result));
+            }
+            return result;
+        });
+    }
+    loadGgGlb(path, options = defaultLoadOptions) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const loadOptions = Object.assign(Object.assign({}, defaultLoadOptions), options);
+            const { resources, meta } = yield this.loadGgGlbResources(path, loadOptions.cachingStrategy);
+            const result = {
+                entities: resources.map(({ object3D, body }) => new gg_3d_entity_1.Gg3dEntity(object3D, body)),
+                meta,
+            };
+            if (loadOptions.loadProps) {
+                result.props = yield Promise.all(meta.dummies
+                    .filter(x => x.is_prop || x.is_scene)
+                    .map(dummy => this.loadGgGlb(dummy.is_prop
+                    ? (loadOptions.propsPath || path.substring(0, path.lastIndexOf('/') + 1)) + dummy.prop_id
+                    : dummy.scene_id, {
+                    loadProps: !!dummy.is_scene,
+                    position: point3_1.Pnt3.add(point3_1.Pnt3.rot(dummy.position, loadOptions.rotation), loadOptions.position),
+                    rotation: quaternion_1.Qtrn.combineRotations(dummy.rotation, loadOptions.rotation),
+                })));
+            }
+            result.entities.forEach(e => {
+                e.position = point3_1.Pnt3.add(point3_1.Pnt3.rot(point3_1.Pnt3.clone(e.position), loadOptions.rotation), loadOptions.position);
+                // FIXME this rotation is wrong
+                e.rotation = quaternion_1.Qtrn.mult(quaternion_1.Qtrn.clone(e.rotation), loadOptions.rotation);
+            });
+            return result;
+        });
+    }
+}
+exports.Gg3dLoader = Gg3dLoader;

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

@@ -0,0 +1,3 @@
+import { BodyOptions } from '../../base/models/body-options';
+export interface Body3DOptions extends BodyOptions {
+}

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

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

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

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

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

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

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

@@ -0,0 +1,35 @@
+import { Point3, Point4 } from '../../base/models/points';
+import { Body3DOptions } from './body-options';
+export declare type Shape3DDescriptor = {
+    shape: 'BOX';
+    dimensions: Point3;
+} | {
+    shape: 'CONE' | 'CYLINDER';
+    radius: number;
+    height: number;
+} | {
+    shape: 'CAPSULE';
+    radius: number;
+    centersDistance: number;
+} | {
+    shape: 'SPHERE';
+    radius: number;
+} | {
+    shape: 'COMPOUND';
+    children: {
+        position?: Point3;
+        rotation?: Point4;
+        shape: Shape3DDescriptor;
+    }[];
+} | {
+    shape: 'CONVEX_HULL';
+    vertices: Point3[];
+} | {
+    shape: 'MESH';
+    vertices: Point3[];
+    faces: [number, number, number][];
+};
+export declare type BodyShape3DDescriptor = {
+    shape: Shape3DDescriptor;
+    body: Partial<Body3DOptions>;
+};

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

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

package/dist/base/clock.d.ts

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

package/dist/base/clock.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Clock = void 0;
+const rxjs_1 = require("rxjs");
+const operators_1 = require("rxjs/operators");
+const now = () => {
+    return (typeof performance === 'undefined' ? Date : performance).now();
+};
+/**
+ * A class, providing ability to track time, fire ticks, provide time elapsed + tick delta with ability to suspend/resume it.
+ */
+class Clock {
+    constructor(tickSource, autoStart = false) {
+        this.tickSource = tickSource;
+        this.tickSub = null;
+        this._tick$ = new rxjs_1.Subject();
+        // state
+        this.startedAt = -1;
+        this.pausedAt = -1;
+        if (autoStart) {
+            this.start();
+        }
+    }
+    // value is global clock time, delta ms from last tick
+    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 now() - this.startedAt;
+    }
+    start() {
+        if (this.isRunning) {
+            return;
+        }
+        this.startedAt = now();
+        this.startListeningTicks();
+    }
+    stop() {
+        this.stopListeningTicks();
+        this.startedAt = this.pausedAt = -1;
+    }
+    pause() {
+        this.stopListeningTicks();
+        this.pausedAt = now();
+    }
+    resume() {
+        if (this.isRunning || this.pausedAt == -1) {
+            return;
+        }
+        this.startedAt += now() - this.pausedAt;
+        this.pausedAt = -1;
+        this.startListeningTicks();
+    }
+    startListeningTicks() {
+        if (this.tickSub) {
+            throw new Error('Clock is already ticking!');
+        }
+        let oldRelativeTime = 0;
+        this.tickSub = this.tickSource
+            .pipe((0, operators_1.map)(() => [oldRelativeTime, now() - this.startedAt]), (0, operators_1.tap)(([_, cur]) => (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;
+/**
+ * A global clock, based on animation frame ticks
+ */
+Clock.animationFrameClock = new Clock((0, rxjs_1.of)(undefined, rxjs_1.animationFrameScheduler).pipe((0, operators_1.repeat)()), true);

package/dist/base/controllers/common.d.ts

@@ -0,0 +1,8 @@
+import { Observable } from 'rxjs';
+import { KeyboardController } from './keyboard.controller';
+export declare type DirectionKeymap = 'arrows' | 'wasd' | 'wasd+arrows';
+export declare type DirectionOutput = {
+    upDown?: boolean;
+    leftRight?: boolean;
+};
+export declare const bindDirectionKeys: (keyboard: KeyboardController, keymap: DirectionKeymap) => Observable<DirectionOutput>;

package/dist/base/controllers/common.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.bindDirectionKeys = void 0;
+const rxjs_1 = require("rxjs");
+const operators_1 = require("rxjs/operators");
+const bindDirectionKeys = (keyboard, keymap) => {
+    const keys = [[], [], [], []];
+    if (keymap.includes('wasd')) {
+        keys[0].push('KeyW');
+        keys[1].push('KeyA');
+        keys[2].push('KeyS');
+        keys[3].push('KeyD');
+    }
+    if (keymap.includes('arrows')) {
+        keys[0].push('ArrowUp');
+        keys[1].push('ArrowLeft');
+        keys[2].push('ArrowDown');
+        keys[3].push('ArrowRight');
+    }
+    return (0, rxjs_1.combineLatest)(keys.map(x => keyboard.bindMany(...x))).pipe((0, operators_1.map)(moveDirection => {
+        const result = {};
+        if (moveDirection.includes(true)) {
+            const [f, l, b, r] = moveDirection;
+            if (f != b)
+                result.upDown = f;
+            if (l != r)
+                result.leftRight = l;
+        }
+        return result;
+    }));
+};
+exports.bindDirectionKeys = bindDirectionKeys;

package/dist/base/controllers/i-controller.d.ts

@@ -0,0 +1,4 @@
+export interface IController {
+    start(): Promise<void>;
+    stop(): Promise<void>;
+}

package/dist/base/controllers/i-controller.js

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

package/dist/base/controllers/keyboard.controller.d.ts

@@ -0,0 +1,16 @@
+import { IController } from './i-controller';
+import { Observable } from 'rxjs';
+export declare class KeyboardController implements IController {
+    private bindings;
+    constructor();
+    private _running;
+    get running(): boolean;
+    bind(code: string): Observable<boolean>;
+    bindMany(...codes: string[]): Observable<boolean>;
+    emulateKeyDown(code: string): void;
+    emulateKeyUp(code: string): void;
+    emulateKeyPress(code: string): void;
+    start(): Promise<void>;
+    private handleKeys;
+    stop(): Promise<void>;
+}