@gg-web-engine/core 0.0.18 → 0.0.20

package/dist/3d/loader.js

@@ -18,8 +18,8 @@ export var CachingStrategy;
 })(CachingStrategy || (CachingStrategy = {}));
 const defaultLoadOptions = {
     cachingStrategy: CachingStrategy.Nothing,
-    position: { x: 0, y: 0, z: 0 },
-    rotation: { x: 0, y: 0, z: 0, w: 1 },
+    position: Pnt3.O,
+    rotation: Qtrn.O,
     loadProps: true,
 };
 const cloneLoadResourcesResult = (loadResult) => ({

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

@@ -46,19 +46,20 @@ export class BaseGgRenderer extends GgEntity {
     onSpawned(world) {
         super.onSpawned(world);
         this._rendererSize$.next(null);
-        if (this.rendererOptions.size == 'fullscreen' || this.rendererOptions.size instanceof Function) {
+        if (this.rendererOptions.size == 'fullscreen' || typeof this.rendererOptions.size === 'function') {
             if (this.canvas) {
                 this.canvas.style.position = 'absolute';
             }
             merge(fromEvent(window, 'resize').pipe(auditTime(100)), fromEvent(window, 'orientationchange'))
                 .pipe(takeUntil(this._onRemoved$), map(() => ({ x: window.innerWidth, y: window.innerHeight })), startWith({ x: window.innerWidth, y: window.innerHeight }))
                 .subscribe(size => {
-                this._rendererSize$.next(this.rendererOptions.size instanceof Function ? this.rendererOptions.size(size) : size);
+                this._rendererSize$.next(typeof this.rendererOptions.size === 'function' ? this.rendererOptions.size(size) : size);
             });
         }
         else if (this.rendererOptions.size instanceof Observable ||
             // for cases when project uses two separate rxjs packages, instanceof can return false for observable
-            (!!this.rendererOptions.subscribe !== undefined && !!this.rendererOptions.pipe !== undefined)) {
+            (this.rendererOptions.size.subscribe !== undefined &&
+                this.rendererOptions.size.pipe !== undefined)) {
             this.rendererOptions.size.pipe(takeUntil(this._onRemoved$)).subscribe(newSize => {
                 this._rendererSize$.next(newSize);
             });

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

@@ -36,7 +36,9 @@ export declare abstract class GgEntity {
     protected _active: boolean;
     get active(): boolean;
     set active(value: boolean);
+    parent: GgEntity | null;
     protected _children: GgEntity[];
+    get children(): GgEntity[];
     addChildren(...entities: GgEntity[]): void;
     removeChildren(entities: GgEntity[], dispose?: boolean): void;
     protected _onSpawned$: Subject<void>;

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

@@ -27,6 +27,7 @@ export class GgEntity {
          * The flag whether entity should listen to ticks. If set to false, ticks will not be propagated to this entity
          * */
         this._active = true;
+        this.parent = null;
         this._children = [];
         this._onSpawned$ = new Subject();
         this._onRemoved$ = new Subject();
@@ -46,7 +47,16 @@ export class GgEntity {
     set active(value) {
         this._active = value;
     }
+    get children() {
+        return [...this._children];
+    }
     addChildren(...entities) {
+        for (const entity of entities) {
+            if (entity.parent) {
+                entity.parent.removeChildren([entity]);
+            }
+            entity.parent = this;
+        }
         this._children.push(...entities);
         if (this._world) {
             for (const item of entities) {
@@ -56,8 +66,9 @@ export class GgEntity {
     }
     removeChildren(entities, dispose = false) {
         this._children = this._children.filter(c => !entities.includes(c));
-        if (this._world) {
-            for (const item of entities) {
+        for (const item of entities) {
+            item.parent = null;
+            if (this._world) {
                 this._world.removeEntity(item, dispose);
             }
         }
@@ -80,7 +91,7 @@ export class GgEntity {
     // 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() {
         if (this.world) {
-            this.world.removeEntity(this);
+            this.world.removeEntity(this, false);
         }
         this._onSpawned$.complete();
         this._onRemoved$.complete();

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

@@ -18,6 +18,6 @@ export declare abstract class GgPositionableEntity<D, R> extends GgEntity {
     get scale(): D;
     get scale$(): Observable<D>;
     set scale(value: D);
-    protected constructor();
+    constructor();
     onSpawned(world: GgWorld<D, R>): void;
 }

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

@@ -10,6 +10,6 @@ export function createInlineTickController(world, tickOrder = GGTickOrder.CONTRO
     const controller = new InlineTickController(tickOrder);
     world.addEntity(controller);
     return controller.tick$.pipe(finalize(() => {
-        world.removeEntity(controller);
+        world.removeEntity(controller, true);
     }));
 }

package/dist/base/entities/mixins/renderable-entity.mixin.d.ts

@@ -0,0 +1,10 @@
+import { GgEntity } from '../gg-entity';
+export declare abstract class RenderableEntityMixin extends GgEntity {
+    private _visible;
+    get visible(): boolean;
+    get worldVisible(): boolean;
+    set visible(value: boolean);
+    updateVisibility(): void;
+    addChildren(...entities: GgEntity[]): void;
+    removeChildren(entities: GgEntity[], dispose?: boolean): void;
+}

package/dist/base/entities/mixins/renderable-entity.mixin.js

@@ -0,0 +1,57 @@
+import { GgEntity } from '../gg-entity';
+const updateRecv = (item) => {
+    if (!!item.updateVisibility) {
+        item.updateVisibility();
+    }
+    else {
+        updateChildrenRecv(item);
+    }
+};
+const updateChildrenRecv = (item) => {
+    for (const child of item.children) {
+        updateRecv(child);
+    }
+};
+export class RenderableEntityMixin extends GgEntity {
+    constructor() {
+        super(...arguments);
+        this._visible = true;
+    }
+    get visible() {
+        return this._visible;
+    }
+    get worldVisible() {
+        let item = this;
+        while (true) {
+            if (item.visible === false) {
+                return false;
+            }
+            if (!item.parent) {
+                break;
+            }
+            item = item.parent;
+        }
+        return true;
+    }
+    set visible(value) {
+        this._visible = value;
+        this.updateVisibility();
+    }
+    updateVisibility() {
+        updateChildrenRecv(this);
+    }
+    addChildren(...entities) {
+        super.addChildren(...entities);
+        for (const entity of entities) {
+            updateRecv(entity);
+        }
+    }
+    removeChildren(entities, dispose = false) {
+        super.removeChildren(entities, dispose);
+        if (!dispose) {
+            for (const entity of entities) {
+                updateRecv(entity);
+            }
+        }
+    }
+}

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

@@ -3,6 +3,7 @@ import { GgEntity } from './entities/gg-entity';
 import { GgPhysicsWorld } from './interfaces/gg-physics-world';
 import { GgVisualScene } from './interfaces/gg-visual-scene';
 import { KeyboardInput } from './inputs/keyboard.input';
+import { RenderableEntityMixin } from './entities/mixins/renderable-entity.mixin';
 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;
@@ -22,7 +23,7 @@ export declare abstract class GgWorld<D, R, V extends GgVisualScene<D, R> = GgVi
     get worldTime(): number;
     createClock(autoStart: boolean): PausableClock;
     dispose(): void;
-    abstract addPrimitiveRigidBody(descr: any, position?: D, rotation?: R): GgPositionableEntity<D, R>;
+    abstract addPrimitiveRigidBody(descr: any, position?: D, rotation?: R): GgPositionableEntity<D, R> & RenderableEntityMixin;
     addEntity(entity: GgEntity): void;
     removeEntity(entity: GgEntity, dispose?: boolean): void;
     protected commands: {

package/dist/base/gg-world.js

@@ -27,8 +27,9 @@ export class GgWorld {
         this.commands = {};
         GgStatic.instance.worlds.push(this);
         GgStatic.instance.selectedWorld = this;
-        this.keyboardInput.start().then();
+        this.keyboardInput.start();
         if (consoleEnabled) {
+            // TODO this listener should be outside of the world
             this.keyboardInput
                 .bind('Backquote')
                 .pipe(filter(x => x))
@@ -120,7 +121,7 @@ export class GgWorld {
     }
     dispose() {
         this.worldClock.stop();
-        this.keyboardInput.stop().then();
+        this.keyboardInput.stop();
         for (let i = 0; i < this.children.length; i++) {
             this.children[i].onRemoved();
             this.children[i].dispose();
@@ -140,7 +141,7 @@ export class GgWorld {
         this.tickListeners.sort((l1, l2) => l1.tickOrder - l2.tickOrder);
         entity.onSpawned(this);
     }
-    removeEntity(entity, dispose = true) {
+    removeEntity(entity, dispose = false) {
         if (entity.world) {
             if (entity.world !== this) {
                 throw new Error('Entity is not a part of this world');

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

@@ -37,5 +37,5 @@ export declare class DirectionKeyboardInput extends Input {
     /**
      * Called when the input handling should start.
      */
-    protected startInternal(): Promise<void>;
+    protected startInternal(): void;
 }

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

@@ -1,12 +1,3 @@
-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());
-    });
-};
 import { combineLatest, Subject, takeUntil } from 'rxjs';
 import { map } from 'rxjs/operators';
 import { Input } from './input';
@@ -40,42 +31,40 @@ export class DirectionKeyboardInput extends Input {
      * Called when the input handling should start.
      */
     startInternal() {
-        return __awaiter(this, void 0, void 0, function* () {
-            // Initialize an array to hold the keys to listen for
-            const keys = [[], [], [], []];
-            // Add the "wasd" keys to the array if specified in the keymap
-            if (this.keymap.includes('wasd')) {
-                keys[0].push('KeyW');
-                keys[1].push('KeyA');
-                keys[2].push('KeyS');
-                keys[3].push('KeyD');
+        // Initialize an array to hold the keys to listen for
+        const keys = [[], [], [], []];
+        // Add the "wasd" keys to the array if specified in the keymap
+        if (this.keymap.includes('wasd')) {
+            keys[0].push('KeyW');
+            keys[1].push('KeyA');
+            keys[2].push('KeyS');
+            keys[3].push('KeyD');
+        }
+        // Add the arrow keys to the array if specified in the keymap
+        if (this.keymap.includes('arrows')) {
+            keys[0].push('ArrowUp');
+            keys[1].push('ArrowLeft');
+            keys[2].push('ArrowDown');
+            keys[3].push('ArrowRight');
+        }
+        // Bind to the keyboard events for the specified keys
+        combineLatest(keys.map(x => this.keyboard.bindMany(...x)))
+            .pipe(
+        // Stop listening when the `stop$` signal is received
+        takeUntil(this.stop$), 
+        // Map the key states to a `DirectionKeyboardOutput` object
+        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;
             }
-            // Add the arrow keys to the array if specified in the keymap
-            if (this.keymap.includes('arrows')) {
-                keys[0].push('ArrowUp');
-                keys[1].push('ArrowLeft');
-                keys[2].push('ArrowDown');
-                keys[3].push('ArrowRight');
-            }
-            // Bind to the keyboard events for the specified keys
-            combineLatest(keys.map(x => this.keyboard.bindMany(...x)))
-                .pipe(
-            // Stop listening when the `stop$` signal is received
-            takeUntil(this.stop$), 
-            // Map the key states to a `DirectionKeyboardOutput` object
-            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;
-            }))
-                // Emit the resulting `DirectionKeyboardOutput` object through the `_output$` subject
-                .subscribe(this._output$);
-        });
+            return result;
+        }))
+            // Emit the resulting `DirectionKeyboardOutput` object through the `_output$` subject
+            .subscribe(o => this._output$.next(o));
     }
 }

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

@@ -24,27 +24,25 @@ export declare abstract class Input<TStartParams extends any[] = [], TStopParams
      */
     get running(): boolean;
     /**
-     * An asynchronous method that starts the input. Do not override it
+     * A method that starts the input. Do not override it
      * @param args - An array of input arguments for the start method.
      * @returns A Promise that resolves when the input is started.
      */
-    start(...args: TStartParams): Promise<void>;
+    start(...args: TStartParams): void;
     /**
-     * An asynchronous method that stops the input. Do not override it
+     * A method that stops the input. Do not override it
      * @param args - An array of input arguments for the stop method.
-     * @returns A Promise that resolves when the input is stopped.
      */
-    stop(...args: TStopParams): Promise<void>;
+    stop(...args: TStopParams): void;
     /**
-     * An abstract asynchronous method that starts the input.
+     * An abstract method that starts the input.
      * @param args - An array of input arguments for the start method.
-     * @returns A Promise that resolves when the process is started.
      */
-    protected abstract startInternal(...args: TStartParams): Promise<void>;
+    protected abstract startInternal(...args: TStartParams): void;
     /**
-     * An asynchronous method that stops the input.
+     * A method that stops the input.
      * @param args - An array of input arguments for the stop method.
      * @returns A Promise that resolves when the process is stopped.
      */
-    protected stopInternal(...args: TStopParams): Promise<void>;
+    protected stopInternal(...args: TStopParams): void;
 }

package/dist/base/inputs/input.js

@@ -1,12 +1,3 @@
-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());
-    });
-};
 import { Subject } from 'rxjs';
 /**
  * An abstract class that provides basic implementation for Input class.
@@ -37,40 +28,33 @@ export class Input {
         return this._running;
     }
     /**
-     * An asynchronous method that starts the input. Do not override it
+     * A method that starts the input. Do not override it
      * @param args - An array of input arguments for the start method.
      * @returns A Promise that resolves when the input is started.
      */
     start(...args) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this.running) {
-                return;
-            }
-            yield this.startInternal(...args);
-            this._running = true;
-        });
+        if (this.running) {
+            return;
+        }
+        this.startInternal(...args);
+        this._running = true;
     }
     /**
-     * An asynchronous method that stops the input. Do not override it
+     * A method that stops the input. Do not override it
      * @param args - An array of input arguments for the stop method.
-     * @returns A Promise that resolves when the input is stopped.
      */
     stop(...args) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!this.running) {
-                return;
-            }
-            this.stop$.next();
-            yield this.stopInternal(...args);
-            this._running = false;
-        });
+        if (!this.running) {
+            return;
+        }
+        this.stop$.next();
+        this.stopInternal(...args);
+        this._running = false;
     }
     /**
-     * An asynchronous method that stops the input.
+     * A method that stops the input.
      * @param args - An array of input arguments for the stop method.
      * @returns A Promise that resolves when the process is stopped.
      */
-    stopInternal(...args) {
-        return __awaiter(this, void 0, void 0, function* () { });
-    }
+    stopInternal(...args) { }
 }

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

@@ -7,12 +7,22 @@ import { Observable } from 'rxjs';
  */
 export declare class KeyboardInput extends Input {
     private bindings;
+    /**
+     * Flag which disables handling key downs, when document has some "typeable" element focused
+     */
+    skipKeyDownsOnExternalFocus: boolean;
+    /**
+     * Which element types should filter key downs when focused
+     */
+    externalFocusBlacklist: {
+        new (): HTMLElement;
+    }[];
     /**
      * Creates a new instance of the `KeyboardInput` class.
      */
     constructor();
-    protected startInternal(): Promise<void>;
-    protected stopInternal(): Promise<void>;
+    protected startInternal(): void;
+    protected stopInternal(): void;
     /**
      * Creates an observable that emits a boolean whenever a key with the given code is pressed or released
      * @param code The key code to bind the observable to
@@ -42,4 +52,6 @@ export declare class KeyboardInput extends Input {
      */
     emulateKeyPress(code: string): void;
     private handleKeys;
+    private onPointerLockChange;
+    resetAllKeys(): void;
 }

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

@@ -1,15 +1,6 @@
-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());
-    });
-};
 import { Input } from './input';
 import { BehaviorSubject, combineLatest, finalize, NEVER } from 'rxjs';
-import { map } from 'rxjs/operators';
+import { distinctUntilChanged, map } from 'rxjs/operators';
 /**
  * A main keyboard input: it does not have own key bindings, but provides an API to bind keys.
  * It is responsible for listening key up/down events (when running!) and emit the events to subscribers.
@@ -22,19 +13,35 @@ export class KeyboardInput extends Input {
     constructor() {
         super();
         this.bindings = {};
+        /**
+         * Flag which disables handling key downs, when document has some "typeable" element focused
+         */
+        this.skipKeyDownsOnExternalFocus = true;
+        /**
+         * Which element types should filter key downs when focused
+         */
+        this.externalFocusBlacklist = [
+            HTMLInputElement,
+            HTMLTextAreaElement,
+            HTMLSelectElement,
+            HTMLButtonElement,
+        ];
         this.handleKeys = this.handleKeys.bind(this);
+        this.resetAllKeys = this.resetAllKeys.bind(this);
+        this.onPointerLockChange = this.onPointerLockChange.bind(this);
     }
     startInternal() {
-        return __awaiter(this, void 0, void 0, function* () {
-            window.addEventListener('keydown', this.handleKeys);
-            window.addEventListener('keyup', this.handleKeys);
-        });
+        window.addEventListener('keydown', this.handleKeys);
+        window.addEventListener('keyup', this.handleKeys);
+        window.addEventListener('blur', this.resetAllKeys);
+        document.addEventListener('pointerlockchange', this.onPointerLockChange);
     }
     stopInternal() {
-        return __awaiter(this, void 0, void 0, function* () {
-            window.removeEventListener('keydown', this.handleKeys);
-            window.removeEventListener('keyup', this.handleKeys);
-        });
+        window.removeEventListener('keydown', this.handleKeys);
+        window.removeEventListener('keyup', this.handleKeys);
+        window.removeEventListener('blur', this.resetAllKeys);
+        document.addEventListener('pointerlockchange', this.onPointerLockChange);
+        this.resetAllKeys();
     }
     /**
      * Creates an observable that emits a boolean whenever a key with the given code is pressed or released
@@ -47,7 +54,7 @@ export class KeyboardInput extends Input {
         }
         const subj = new BehaviorSubject(false);
         this.bindings[code].push(subj);
-        return subj.pipe(finalize(() => {
+        return subj.pipe(distinctUntilChanged(), finalize(() => {
             this.bindings[code].splice(this.bindings[code].indexOf(subj), 1);
             subj.complete();
         }));
@@ -80,7 +87,7 @@ export class KeyboardInput extends Input {
                 this.bindings[codes[i]].splice(this.bindings[codes[i]].indexOf(subjects[i]), 1);
                 subjects[i].complete();
             }
-        }), map(values => values.includes(true)));
+        }), map(values => values.includes(true)), distinctUntilChanged());
     }
     /**
      * Emulates a key down event for the given key code
@@ -119,8 +126,28 @@ export class KeyboardInput extends Input {
             return;
         }
         const pressed = e.type == 'keydown';
+        if (pressed && this.skipKeyDownsOnExternalFocus && document.activeElement) {
+            for (const k of this.externalFocusBlacklist) {
+                if (document.activeElement instanceof k) {
+                    return;
+                }
+            }
+        }
         for (const subj of this.bindings[e.code] || []) {
             subj.next(pressed);
         }
     }
+    onPointerLockChange() {
+        // In chrome, if we press key, then exit pointer lock with Escape key, and then release key, the event will not be fired and key will "stuck" in down state
+        if (!document.pointerLockElement) {
+            this.resetAllKeys();
+        }
+    }
+    resetAllKeys() {
+        for (const code in this.bindings) {
+            for (const subj of this.bindings[code] || []) {
+                subj.next(false);
+            }
+        }
+    }
 }

package/dist/base/inputs/mouse.input.d.ts

@@ -56,13 +56,13 @@ export declare class MouseInput extends Input<[], [unlockPointer?: boolean]> {
     /**
      An observable of the wheel scrolling.
      */
+    private _wheel$;
     get wheel$(): Observable<number>;
     get isPointerLocked(): boolean;
     private readonly options;
     private _delta$;
     private _position$;
     private _multiTouchPositions$;
-    private _wheel$;
     private stopped$;
     private _state$;
     get state(): MouseInputState;
@@ -79,12 +79,12 @@ export declare class MouseInput extends Input<[], [unlockPointer?: boolean]> {
      @param {MouseInputOptions} options - The options for the MouseInput.
      */
     constructor(options?: Partial<MouseInputOptions>);
-    protected startInternal(): Promise<void>;
+    protected startInternal(): void;
     /**
      Stop listening for mouse movement events.
      @param {boolean} [unlockPointer=true] - Whether to exit pointer lock.
      */
-    protected stopInternal(unlockPointer?: boolean): Promise<void>;
+    protected stopInternal(unlockPointer?: boolean): void;
     /**
      Request pointer lock on the canvas element.
      */