@gg-web-engine/core 0.0.37 → 0.0.39

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

@@ -2,39 +2,105 @@ import { Subject } from 'rxjs';
 import { map, tap } from 'rxjs/operators';
 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.
+ * A class providing the ability to track time, fire ticks, provide time elapsed, and tick delta with the ability to suspend/resume it.
  */
 export class PausableClock {
+    /**
+     * Constructs a new PausableClock instance.
+     * @param autoStart Indicates whether the clock should start automatically upon creation.
+     * @param parentClock The parent clock to synchronize with. Defaults to GgGlobalClock instance.
+     */
     constructor(autoStart = false, parentClock = GgGlobalClock.instance) {
         this.parentClock = parentClock;
         this.tickSub = null;
         this._tick$ = new Subject();
-        // state
+        // State variables
         this.startedAt = -1;
         this.oldRelativeTime = 0; // "elapsed", emitted on last tick
         this.pausedAt = -1;
+        this.lastStopElapsed = 0;
+        this._timeScale = 1;
+        this.pausedByTimescale = false;
         if (autoStart) {
             this.start();
         }
     }
+    /**
+     * Observable stream of ticks, emitting an array containing the current time and the tick delta.
+     */
     get tick$() {
         return this._tick$.pipe(map(([oldTime, newTime]) => [newTime, newTime - oldTime]));
     }
+    /**
+     * Checks if the clock is currently running.
+     */
     get isRunning() {
         return !!this.tickSub;
     }
+    /**
+     * Checks if the clock is currently paused.
+     */
     get isPaused() {
         return this.pausedAt !== -1;
     }
+    /**
+     * Checks if the clock is stopped.
+     */
+    get isStopped() {
+        return this.startedAt === -1;
+    }
+    /**
+     * Gets the time scale of the clock.
+     */
+    get timeScale() {
+        return this._timeScale;
+    }
+    /**
+     * Sets the time scale of the clock.
+     */
+    set timeScale(value) {
+        if (value === this._timeScale && !(this.pausedByTimescale && value !== 0))
+            return;
+        if (value === 0) {
+            if (!this.isPaused) {
+                this.pause();
+                this.pausedByTimescale = true;
+            }
+            return;
+        }
+        if (this.isPaused && this.pausedByTimescale) {
+            this.resume();
+            this.pausedByTimescale = false;
+        }
+        if (!this.isStopped) {
+            const cur = this.isPaused ? this.pausedAt : this.parentClock.elapsedTime;
+            this.startedAt = cur - ((cur - this.startedAt) * this.timeScale) / value;
+        }
+        this._timeScale = value;
+    }
+    /**
+     * Gets the elapsed time since the clock started.
+     */
     get elapsedTime() {
+        if (this.isStopped) {
+            return this.lastStopElapsed;
+        }
         if (this.isPaused) {
-            return this.pausedAt - this.startedAt;
+            return this._timeScale * (this.pausedAt - this.startedAt);
         }
-        return this.parentClock.elapsedTime - this.startedAt;
+        return this._timeScale * (this.parentClock.elapsedTime - this.startedAt);
     }
+    /**
+     * Creates a child clock.
+     * @param autoStart Indicates whether the child clock should start automatically.
+     * @returns A new instance of PausableClock.
+     */
     createChildClock(autoStart) {
         return new PausableClock(autoStart, this);
     }
+    /**
+     * Starts the clock.
+     */
     start() {
         if (this.isRunning) {
             return;
@@ -43,14 +109,25 @@ export class PausableClock {
         this.startedAt = this.parentClock.elapsedTime;
         this.startListeningTicks();
     }
+    /**
+     * Stops the clock.
+     */
     stop() {
         this.stopListeningTicks();
+        this.lastStopElapsed = this.elapsedTime;
         this.startedAt = this.pausedAt = -1;
     }
+    /**
+     * Pauses the clock.
+     */
     pause() {
         this.stopListeningTicks();
         this.pausedAt = this.parentClock.elapsedTime;
+        this.pausedByTimescale = false;
     }
+    /**
+     * Resumes the clock.
+     */
     resume() {
         if (this.isRunning || this.pausedAt == -1) {
             return;
@@ -59,14 +136,20 @@ export class PausableClock {
         this.pausedAt = -1;
         this.startListeningTicks();
     }
+    /**
+     * Starts listening for ticks from the parent clock.
+     */
     startListeningTicks() {
         if (this.tickSub) {
             throw new Error('Clock is already ticking!');
         }
         this.tickSub = this.parentClock.tick$
-            .pipe(map(([parentElapsed, _]) => [this.oldRelativeTime, parentElapsed - this.startedAt]), tap(([_, cur]) => (this.oldRelativeTime = cur)))
+            .pipe(map(([_, d]) => [this.oldRelativeTime, this.oldRelativeTime + d * this.timeScale]), tap(([_, cur]) => (this.oldRelativeTime = cur)))
             .subscribe(this._tick$);
     }
+    /**
+     * Stops listening for ticks from the parent clock.
+     */
     stopListeningTicks() {
         var _a;
         (_a = this.tickSub) === null || _a === void 0 ? void 0 : _a.unsubscribe();

package/dist/base/components/physics/i-body.component.d.ts

@@ -1,7 +1,7 @@
 import { IEntity } from '../../entities/i-entity';
 import { IWorldComponent } from '../i-world-component';
 import { GgWorld, PhysicsTypeDocRepo, VisualTypeDocRepo } from '../../gg-world';
-import { CollisionGroup } from '../../models/body-options';
+import { CollisionGroup, DebugBodySettings } from '../../models/body-options';
 export interface IBodyComponent<D, R, TypeDoc extends PhysicsTypeDocRepo<D, R> = PhysicsTypeDocRepo<D, R>> extends IWorldComponent<D, R, VisualTypeDocRepo<D, R>, TypeDoc> {
     entity: IEntity | null;
     position: D;
@@ -11,6 +11,8 @@ export interface IBodyComponent<D, R, TypeDoc extends PhysicsTypeDocRepo<D, R> =
     set ownCollisionGroups(value: CollisionGroup[] | 'all');
     get interactWithCollisionGroups(): CollisionGroup[];
     set interactWithCollisionGroups(value: CollisionGroup[] | 'all');
+    /** body info for physics debugger view */
+    readonly debugBodySettings: DebugBodySettings;
     clone(): IBodyComponent<D, R, TypeDoc>;
     addToWorld(world: GgWorld<D, R, VisualTypeDocRepo<D, R>, TypeDoc>): void;
     removeFromWorld(world: GgWorld<D, R, VisualTypeDocRepo<D, R>, TypeDoc>): void;

package/dist/base/components/physics/i-physics-world.component.d.ts

@@ -1,12 +1,16 @@
-import { GgWorld, PhysicsTypeDocRepo } from '../../gg-world';
-import { IDebugPhysicsDrawer } from '../../interfaces/i-debug-physics-drawer';
+import { PhysicsTypeDocRepo } from '../../gg-world';
 import { IComponent } from '../i-component';
 import { CollisionGroup } from '../../models/body-options';
+import { Subject } from 'rxjs';
 export interface IPhysicsWorldComponent<D, R, TypeDoc extends PhysicsTypeDocRepo<D, R> = PhysicsTypeDocRepo<D, R>> extends IComponent {
     readonly factory: TypeDoc['factory'];
     gravity: D;
-    timeScale: number;
-    get physicsDebugViewActive(): boolean;
+    /** event emitter, emits newly added physics components */
+    readonly added$: Subject<TypeDoc['rigidBody'] | TypeDoc['trigger'] | any>;
+    /** event emitter, emits just removed physics components */
+    readonly removed$: Subject<TypeDoc['rigidBody'] | TypeDoc['trigger'] | any>;
+    /** list of currently added to world physics components */
+    readonly children: (TypeDoc['rigidBody'] | TypeDoc['trigger'] | any)[];
     init(): Promise<void>;
     /**
      * Runs simulation of the physics world.
@@ -16,6 +20,4 @@ export interface IPhysicsWorldComponent<D, R, TypeDoc extends PhysicsTypeDocRepo
     simulate(delta: number): void;
     registerCollisionGroup(): CollisionGroup;
     deregisterCollisionGroup(group: CollisionGroup): void;
-    startDebugger(world: GgWorld<D, R>, drawer: IDebugPhysicsDrawer<D, R>): void;
-    stopDebugger(world: GgWorld<D, R>): void;
 }

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

@@ -26,6 +26,10 @@ export declare abstract class IRendererComponent<D, R, VTypeDoc extends VisualTy
     entity: IEntity | null;
     /** Specifies the options for the renderer. */
     readonly rendererOptions: RendererOptions;
+    /** get flag whether renderer shows physics debugger view */
+    abstract get physicsDebugViewActive(): boolean;
+    /** turns on/off physics debugger view for this renderer */
+    abstract set physicsDebugViewActive(value: boolean);
     protected constructor(scene: IVisualSceneComponent<D, R, VTypeDoc>, canvas?: HTMLCanvasElement | undefined, options?: Partial<RendererOptions>);
     /**
      * Renders the scene.

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

@@ -1,10 +1,6 @@
-import { IDebugPhysicsDrawer } from '../../interfaces/i-debug-physics-drawer';
 import { IComponent } from '../i-component';
 import { VisualTypeDocRepo } from '../../gg-world';
 export interface IVisualSceneComponent<D, R, TypeDoc extends VisualTypeDocRepo<D, R> = VisualTypeDocRepo<D, R>> extends IComponent {
     readonly factory: TypeDoc['factory'];
-    readonly debugPhysicsDrawerClass?: {
-        new (): IDebugPhysicsDrawer<D, R, TypeDoc>;
-    };
     init(): Promise<void>;
 }

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

@@ -1,5 +1,5 @@
 import { GgWorld, PhysicsTypeDocRepo, VisualTypeDocRepo } from '../gg-world';
-import { Subject } from 'rxjs';
+import { Observable, Subject } from 'rxjs';
 import { IWorldComponent } from '../components/i-world-component';
 /**
  * Engine's default tick orders: the less value, the earlier tick will be run.
@@ -34,7 +34,7 @@ export declare abstract class IEntity<D = any, R = any, VTypeDoc extends VisualT
     /**
      * The flag whether entity should listen to ticks. If set to false, ticks will not be propagated to this entity
      * */
-    protected _active: boolean;
+    protected _selfActive: boolean;
     get active(): boolean;
     set active(value: boolean);
     parent: IEntity | null;
@@ -48,6 +48,8 @@ export declare abstract class IEntity<D = any, R = any, VTypeDoc extends VisualT
     removeComponents(components: IWorldComponent<D, R, VTypeDoc, PTypeDoc>[], dispose?: boolean): void;
     protected _onSpawned$: Subject<void>;
     protected _onRemoved$: Subject<void>;
+    get onSpawned$(): Observable<void>;
+    get onRemoved$(): Observable<void>;
     onSpawned(world: GgWorld<D, R, VTypeDoc, PTypeDoc>): void;
     onRemoved(): void;
     dispose(): void;

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

@@ -26,7 +26,7 @@ export class IEntity {
         /**
          * The flag whether entity should listen to ticks. If set to false, ticks will not be propagated to this entity
          * */
-        this._active = true;
+        this._selfActive = true;
         this.parent = null;
         this._children = [];
         this._components = [];
@@ -43,10 +43,10 @@ export class IEntity {
         this._name = value;
     }
     get active() {
-        return this._active;
+        return this._selfActive && (!this.parent || this.parent.active);
     }
     set active(value) {
-        this._active = value;
+        this._selfActive = value;
     }
     get children() {
         return [...this._children];
@@ -100,6 +100,12 @@ export class IEntity {
             }
         }
     }
+    get onSpawned$() {
+        return this._onSpawned$.asObservable();
+    }
+    get onRemoved$() {
+        return this._onRemoved$.asObservable();
+    }
     onSpawned(world) {
         this._world = world;
         for (const c of this._components) {

package/dist/base/entities/i-renderer.entity.d.ts

@@ -23,6 +23,10 @@ export declare abstract class IRendererEntity<D, R, TypeDoc extends VisualTypeDo
      */
     get rendererSize(): Point2 | null;
     get rendererOptions(): RendererOptions;
+    /** get flag whether renderer shows physics debugger view */
+    get physicsDebugViewActive(): boolean;
+    /** turns on/off physics debugger view for this renderer */
+    set physicsDebugViewActive(value: boolean);
     /**
      Initializes a new instance of the BaseGgRenderer class.
      * @param renderer

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

@@ -38,6 +38,14 @@ export class IRendererEntity extends IEntity {
     get rendererOptions() {
         return this.renderer.rendererOptions;
     }
+    /** get flag whether renderer shows physics debugger view */
+    get physicsDebugViewActive() {
+        return this.renderer.physicsDebugViewActive;
+    }
+    /** turns on/off physics debugger view for this renderer */
+    set physicsDebugViewActive(value) {
+        this.renderer.physicsDebugViewActive = value;
+    }
     onSpawned(world) {
         this._rendererSize$.next(null);
         if (this.rendererOptions.size == 'fullscreen' || typeof this.rendererOptions.size === 'function') {

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

@@ -34,6 +34,4 @@ export declare abstract class GgWorld<D, R, VTypeDoc extends VisualTypeDocRepo<D
     position?: D, rotation?: R, material?: unknown): IPositionable<D, R> & IRenderableEntity<D, R, VTypeDoc>;
     addEntity(entity: IEntity): void;
     removeEntity(entity: IEntity, dispose?: boolean): void;
-    get physicsDebugViewActive(): boolean;
-    set physicsDebugViewActive(value: boolean);
 }

package/dist/base/gg-world.js

@@ -7,7 +7,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-import { GgGlobalClock, KeyboardInput, TickOrder, } from '../base';
+import { GgGlobalClock, IRendererEntity, KeyboardInput, TickOrder, } from '../base';
 export class GgWorld {
     constructor(visualScene, physicsWorld) {
         this.visualScene = visualScene;
@@ -30,13 +30,32 @@ export class GgWorld {
                 return '' + window.ggstatic.showStats;
             }), 'args: [0 or 1]; turn on/off stats. Default value is 0');
             window.ggstatic.registerConsoleCommand(this, 'ph_timescale', (...args) => __awaiter(this, void 0, void 0, function* () {
-                this.physicsWorld.timeScale = +args[0];
-                return JSON.stringify(this.physicsWorld.timeScale);
+                this.worldClock.timeScale = +args[0];
+                return JSON.stringify(this.worldClock.timeScale);
             }), 'args: [float]; change time scale of physics engine. Default value is 1.0');
+            window.ggstatic.registerConsoleCommand(this, 'ls_renderers', () => __awaiter(this, void 0, void 0, function* () {
+                return this.children
+                    .filter(e => e instanceof IRendererEntity)
+                    .map(r => r.name)
+                    .join('\n');
+            }), 'no args; print all renderers in selected world');
             window.ggstatic.registerConsoleCommand(this, 'dr_drawphysics', (...args) => __awaiter(this, void 0, void 0, function* () {
-                this.physicsDebugViewActive = ['1', 'true', '+'].includes(args[0]);
-                return '' + this.physicsWorld.physicsDebugViewActive;
-            }), 'args: [0 or 1]; turn on/off physics debug view. Default value is 0');
+                const value = ['1', 'true', '+'].includes(args[0]);
+                const rendererName = args[1];
+                let renderer;
+                if (rendererName) {
+                    renderer = this.children.find(x => x instanceof IRendererEntity && x.name === rendererName);
+                }
+                else {
+                    renderer = this.children.find(x => x instanceof IRendererEntity);
+                }
+                if (renderer) {
+                    renderer.physicsDebugViewActive = value;
+                    return '' + value;
+                }
+                return 'false';
+            }), 'args: [0 or 1] or [0 or 1, string]; turn on/off physics debug view. Second argument expects renderer ' +
+                'name, if not provided first renderer will be picked. Look up for renderer names using command "ls_renderers"');
         }
     }
     static get documentWorlds() {
@@ -56,7 +75,7 @@ export class GgWorld {
                         this.tickListeners[i].tick$.next([elapsed, delta]);
                     }
                 }
-                // run phycics simulation
+                // run physics simulation
                 this.physicsWorld.simulate(delta);
                 // emit tick to all remained entities
                 for (i; i < this.tickListeners.length; i++) {
@@ -126,24 +145,6 @@ export class GgWorld {
             entity.dispose();
         }
     }
-    get physicsDebugViewActive() {
-        return this.physicsWorld.physicsDebugViewActive;
-    }
-    set physicsDebugViewActive(value) {
-        if (this.physicsDebugViewActive === value) {
-            return;
-        }
-        if (value) {
-            const cls = this.visualScene.debugPhysicsDrawerClass;
-            if (!cls) {
-                throw new Error('Debug drawer is not available');
-            }
-            this.physicsWorld.startDebugger(this, new cls());
-        }
-        else {
-            this.physicsWorld.stopDebugger(this);
-        }
-    }
 }
 GgWorld.default_name_counter = 0;
 GgWorld._documentWorlds = [];

package/dist/base/index.d.ts

@@ -21,7 +21,6 @@ export * from './inputs/direction.keyboard.input';
 export * from './inputs/i-input';
 export * from './inputs/keyboard.input';
 export * from './inputs/mouse.input';
-export * from './interfaces/i-debug-physics-drawer';
 export * from './interfaces/i-positionable';
 export * from './models/axis-directions';
 export * from './models/body-options';

package/dist/base/index.js

@@ -21,7 +21,6 @@ export * from './inputs/direction.keyboard.input';
 export * from './inputs/i-input';
 export * from './inputs/keyboard.input';
 export * from './inputs/mouse.input';
-export * from './interfaces/i-debug-physics-drawer';
 export * from './interfaces/i-positionable';
 export * from './models/axis-directions';
 export * from './models/body-options';

package/dist/base/math/point2.d.ts

@@ -12,12 +12,20 @@ export declare class Pnt2 {
     static get nY(): Point2;
     /** clone point */
     static clone(p: Point2): Point2;
+    /** spread point components */
+    static spr(p: Point2): [number, number];
+    /** get negation of the point */
+    static neg(p: Point2): Point2;
     /** add point b to point a */
     static add(a: Point2, b: Point2): Point2;
     /** subtract point b from point a */
     static sub(a: Point2, b: Point2): Point2;
+    /** scale point b by point. The result is the point, where each component is a product of appropriate components of input points */
+    static scale(a: Point2, s: Point2): Point2;
     /** average point between a and b */
     static avg(a: Point2, b: Point2): Point2;
+    /** round point components */
+    static round(p: Point2): Point2;
     /** calculate vector length (squared) */
     static lenSq(v: Point2): number;
     /** calculate vector length */
@@ -32,4 +40,8 @@ export declare class Pnt2 {
     static lerp(a: Point2, b: Point2, t: number): Point2;
     /** angle between vectors in radians */
     static angle(a: Point2, b: Point2): number;
+    /** rotate point around zero by provided angle */
+    static rot(p: Point2, angle: number): Point2;
+    /** rotate point around pivot by provided angle */
+    static rotAround(p: Point2, pivot: Point2, angle: number): Point2;
 }

package/dist/base/math/point2.js

@@ -23,6 +23,14 @@ export class Pnt2 {
     static clone(p) {
         return { x: p.x, y: p.y };
     }
+    /** spread point components */
+    static spr(p) {
+        return [p.x, p.y];
+    }
+    /** get negation of the point */
+    static neg(p) {
+        return { x: -p.x, y: -p.y };
+    }
     /** add point b to point a */
     static add(a, b) {
         return { x: a.x + b.x, y: a.y + b.y };
@@ -31,10 +39,18 @@ export class Pnt2 {
     static sub(a, b) {
         return { x: a.x - b.x, y: a.y - b.y };
     }
+    /** scale point b by point. The result is the point, where each component is a product of appropriate components of input points */
+    static scale(a, s) {
+        return { x: a.x * s.x, y: a.y * s.y };
+    }
     /** average point between a and b */
     static avg(a, b) {
         return { x: (a.x + b.x) / 2, y: (a.y + b.y) / 2 };
     }
+    /** round point components */
+    static round(p) {
+        return { x: Math.round(p.x), y: Math.round(p.y) };
+    }
     /** calculate vector length (squared) */
     static lenSq(v) {
         return v.x * v.x + v.y * v.y;
@@ -75,4 +91,23 @@ export class Pnt2 {
         const magnitudeProduct = Math.sqrt(a.x ** 2 + a.y ** 2) * Math.sqrt(b.x ** 2 + b.y ** 2);
         return Math.acos(dotProduct / magnitudeProduct);
     }
+    /** rotate point around zero by provided angle */
+    static rot(p, angle) {
+        const cos = Math.cos(angle);
+        const sin = Math.sin(angle);
+        return {
+            x: p.x * cos - p.y * sin,
+            y: p.x * sin + p.y * cos,
+        };
+    }
+    /** rotate point around pivot by provided angle */
+    static rotAround(p, pivot, angle) {
+        const cos = Math.cos(angle);
+        const sin = Math.sin(angle);
+        const p0 = { x: p.x - pivot.x, y: p.y - pivot.y };
+        return {
+            x: p0.x * cos - p0.y * sin + pivot.x,
+            y: p0.x * sin + p0.y * cos + pivot.y,
+        };
+    }
 }

package/dist/base/math/point3.d.ts

@@ -16,12 +16,20 @@ export declare class Pnt3 {
     static get nZ(): Point3;
     /** clone point */
     static clone(p: Point3): Point3;
+    /** spread point components */
+    static spr(p: Point3): [number, number, number];
+    /** get negation of the point */
+    static neg(p: Point3): Point3;
     /** add point b to point a */
     static add(a: Point3, b: Point3): Point3;
     /** subtract point b from point a */
     static sub(a: Point3, b: Point3): Point3;
+    /** scale point b by point. The result is the point, where each component is a product of appropriate components of input points */
+    static scale(a: Point3, s: Point3): Point3;
     /** average point between a and b */
     static avg(a: Point3, b: Point3): Point3;
+    /** round point components */
+    static round(p: Point3): Point3;
     /** calculate vector length (squared) */
     static lenSq(v: Point3): number;
     /** calculate vector length */

package/dist/base/math/point3.js

@@ -32,6 +32,14 @@ export class Pnt3 {
     static clone(p) {
         return { x: p.x, y: p.y, z: p.z };
     }
+    /** spread point components */
+    static spr(p) {
+        return [p.x, p.y, p.z];
+    }
+    /** get negation of the point */
+    static neg(p) {
+        return { x: -p.x, y: -p.y, z: -p.z };
+    }
     /** add point b to point a */
     static add(a, b) {
         return { x: a.x + b.x, y: a.y + b.y, z: a.z + b.z };
@@ -40,10 +48,18 @@ export class Pnt3 {
     static sub(a, b) {
         return { x: a.x - b.x, y: a.y - b.y, z: a.z - b.z };
     }
+    /** scale point b by point. The result is the point, where each component is a product of appropriate components of input points */
+    static scale(a, s) {
+        return { x: a.x * s.x, y: a.y * s.y, z: a.z * s.z };
+    }
     /** average point between a and b */
     static avg(a, b) {
         return { x: (a.x + b.x) / 2, y: (a.y + b.y) / 2, z: (a.z + b.z) / 2 };
     }
+    /** round point components */
+    static round(p) {
+        return { x: Math.round(p.x), y: Math.round(p.y), z: Math.round(p.z) };
+    }
     /** calculate vector length (squared) */
     static lenSq(v) {
         return v.x * v.x + v.y * v.y + v.z * v.z;

package/dist/base/math/quaternion.d.ts

@@ -18,6 +18,8 @@ export declare class Qtrn {
      * @returns A new Point4 instance with the same values as the given Point4 object.
      */
     static clone(q: Point4): Point4;
+    /** spread quaternion components */
+    static spr(p: Point4): [number, number, number, number];
     /**
      * Returns the sum of two Point4 objects.
      * @param a The first Point4 object to add.

package/dist/base/math/quaternion.js

@@ -23,6 +23,10 @@ export class Qtrn {
     static clone(q) {
         return { x: q.x, y: q.y, z: q.z, w: q.w };
     }
+    /** spread quaternion components */
+    static spr(p) {
+        return [p.x, p.y, p.z, p.w];
+    }
     /**
      * Returns the sum of two Point4 objects.
      * @param a The first Point4 object to add.

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

@@ -7,3 +7,12 @@ export interface BodyOptions {
     ownCollisionGroups: CollisionGroup[] | 'all';
     interactWithCollisionGroups: CollisionGroup[] | 'all';
 }
+export declare type DebugBodySettings = {
+    shape: any;
+    ignoreTransform?: boolean;
+} & ({
+    type: 'RIGID_STATIC' | 'TRIGGER';
+} | {
+    type: 'RIGID_DYNAMIC';
+    sleeping: boolean;
+});

package/dist/dev/gg-console.ui.js

@@ -67,31 +67,39 @@ List of available commands: `.replace(/ /g, '&nbsp;') + `<span style="color:yell
         };
         document.getElementById('gg-console-close-icon').onmousedown = () => this.destroyUI();
         this.elements.input.onkeydown = event => {
-            if ((event === null || event === void 0 ? void 0 : event.keyCode) === 13) {
+            var _a;
+            if ((event === null || event === void 0 ? void 0 : event.code) === 'Enter') {
                 event.preventDefault();
                 this.onInput().then();
             }
-            else if ((event === null || event === void 0 ? void 0 : event.keyCode) === 38) {
+            else if ((event === null || event === void 0 ? void 0 : event.code) === 'ArrowUp') {
                 event.preventDefault();
                 this.onUsePreviousCommand();
             }
-            else if ((event === null || event === void 0 ? void 0 : event.keyCode) === 40) {
+            else if ((event === null || event === void 0 ? void 0 : event.code) === 'ArrowDown') {
                 event.preventDefault();
                 this.onUseNextCommand();
             }
+            else if ((event === null || event === void 0 ? void 0 : event.code) === 'Backspace') {
+                let input = (_a = this.elements) === null || _a === void 0 ? void 0 : _a.input;
+                if (input) {
+                    let value = input.value || '';
+                    // backspace pressed while input had completion selected.
+                    // Native logic will remove selected text (completion part), we remove one additional character
+                    if ((input.selectionStart || value.length) < value.length && input.selectionEnd == value.length) {
+                        this.elements.input.value = value.substring(0, input.selectionStart || value.length - 1);
+                    }
+                }
+            }
         };
         this.elements.input.oninput = event => {
             var _a;
             let value = ((_a = this.elements) === null || _a === void 0 ? void 0 : _a.input.value) || '';
-            // backspace
-            if (value.length > 0 && event.data === null) {
-                value = value.substring(0, value.length - 1);
-            }
             if (value.trim() === '') {
                 return;
             }
             let autocompletion = window.ggstatic.availableCommands.find((c) => c[0].startsWith(value));
-            if (autocompletion) {
+            if (autocompletion && autocompletion[0].length > value.length) {
                 this.elements.input.value = autocompletion[0];
                 this.elements.input.setSelectionRange(value.length, this.elements.input.value.length);
             }

package/dist/dev/gg-debugger.ui.d.ts

@@ -6,6 +6,10 @@ export declare class GgDebuggerUI {
     private currentWorld;
     setShowStats(selectedWorld: GgWorld<any, any>, value: boolean): void;
     private debugControlsRemoved$;
+    private viewUpdated$;
     get showDebugControls(): boolean;
     setShowDebugControls(selectedWorld: GgWorld<any, any>, value: boolean): void;
+    private snapshot;
+    private makeSnapshot;
+    private renderControls;
 }