@gg-web-engine/core 0.0.24 → 0.0.28

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

@@ -0,0 +1,14 @@
+import { IEntity } from '../../entities/i-entity';
+import { IPhysicsWorldComponent } from './i-physics-world.component';
+import { IWorldComponent } from '../i-world-component';
+import { GgWorld } from '../../gg-world';
+import { IVisualSceneComponent } from '../rendering/i-visual-scene.component';
+export interface IBodyComponent<D, R, PW extends IPhysicsWorldComponent<D, R> = IPhysicsWorldComponent<D, R>> extends IWorldComponent<D, R, IVisualSceneComponent<D, R>, PW> {
+    entity: IEntity | null;
+    position: D;
+    rotation: R;
+    name: string;
+    clone(): IBodyComponent<D, R, PW>;
+    addToWorld(world: GgWorld<D, R, IVisualSceneComponent<D, R>, PW>): void;
+    removeFromWorld(world: GgWorld<D, R, IVisualSceneComponent<D, R>, PW>): void;
+}

package/dist/base/components/physics/i-body.component.js

@@ -0,0 +1 @@
+export {};

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

@@ -1,16 +1,9 @@
-import { IEntity } from '../../entities/i-entity';
 import { IPhysicsWorldComponent } from './i-physics-world.component';
-import { IWorldComponent } from '../i-world-component';
-import { GgWorld } from '../../gg-world';
-import { IVisualSceneComponent } from '../rendering/i-visual-scene.component';
-export interface IRigidBodyComponent<D, R, PW extends IPhysicsWorldComponent<D, R> = IPhysicsWorldComponent<D, R>> extends IWorldComponent<D, R, IVisualSceneComponent<D, R>, PW> {
-    entity: IEntity | null;
-    position: D;
-    rotation: R;
-    name: string;
+import { IBodyComponent } from './i-body.component';
+export interface IRigidBodyComponent<D, R, PW extends IPhysicsWorldComponent<D, R> = IPhysicsWorldComponent<D, R>> extends IBodyComponent<D, R, PW> {
+    linearVelocity: D;
+    angularVelocity: R | D;
     clone(): IRigidBodyComponent<D, R, PW>;
-    addToWorld(world: GgWorld<D, R, IVisualSceneComponent<D, R>, PW>): void;
-    removeFromWorld(world: GgWorld<D, R, IVisualSceneComponent<D, R>, PW>): void;
     /** clear velocities etc. */
     resetMotion(): void;
 }

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

@@ -1,8 +1,10 @@
 import { Observable } from 'rxjs';
 import { IRigidBodyComponent } from './i-rigid-body.component';
 import { IPhysicsWorldComponent } from './i-physics-world.component';
-export interface ITriggerComponent<D, R, PW extends IPhysicsWorldComponent<D, R> = IPhysicsWorldComponent<D, R>> extends IRigidBodyComponent<D, R, PW> {
+import { IBodyComponent } from './i-body.component';
+export interface ITriggerComponent<D, R, PW extends IPhysicsWorldComponent<D, R> = IPhysicsWorldComponent<D, R>> extends IBodyComponent<D, R, PW> {
     get onEntityEntered(): Observable<IRigidBodyComponent<D, R>>;
     get onEntityLeft(): Observable<IRigidBodyComponent<D, R> | null>;
+    clone(): ITriggerComponent<D, R, PW>;
     checkOverlaps(): void;
 }

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

@@ -22,7 +22,7 @@ export class IEntity {
          * a world reference, where this entity was added to
          */
         this._world = null;
-        this._name = '0x' + (IEntity.default_name_counter++).toString(16);
+        this._name = 'e0x' + (IEntity.default_name_counter++).toString(16);
         /**
          * The flag whether entity should listen to ticks. If set to false, ticks will not be propagated to this entity
          * */

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

@@ -1,13 +1,16 @@
-import { IEntity, IPhysicsWorldComponent, IVisualSceneComponent, KeyboardInput, PausableClock, IPositionable, IRenderableEntity } from '../base';
+import { IEntity, IPhysicsWorldComponent, IPositionable, IRenderableEntity, IVisualSceneComponent, KeyboardInput, PausableClock } from '../base';
 export declare abstract class GgWorld<D, R, V extends IVisualSceneComponent<D, R> = IVisualSceneComponent<D, R>, P extends IPhysicsWorldComponent<D, R> = IPhysicsWorldComponent<D, R>> {
     readonly visualScene: V;
     readonly physicsWorld: P;
-    protected readonly consoleEnabled: boolean;
     readonly worldClock: PausableClock;
     readonly keyboardInput: KeyboardInput;
+    private static default_name_counter;
+    name: string;
     readonly children: IEntity[];
     protected readonly tickListeners: IEntity[];
-    constructor(visualScene: V, physicsWorld: P, consoleEnabled?: boolean);
+    private static _documentWorlds;
+    static get documentWorlds(): GgWorld<any, any>[];
+    protected constructor(visualScene: V, physicsWorld: P);
     init(): Promise<void>;
     start(): void;
     pauseWorld(): void;
@@ -20,13 +23,6 @@ export declare abstract class GgWorld<D, R, V extends IVisualSceneComponent<D, R
     abstract addPrimitiveRigidBody(descr: any, position?: D, rotation?: R): IPositionable<D, R> & IRenderableEntity<D, R, V, P>;
     addEntity(entity: IEntity): void;
     removeEntity(entity: IEntity, dispose?: boolean): void;
-    protected commands: {
-        [key: string]: {
-            handler: (...args: string[]) => Promise<string>;
-            doc?: string;
-        };
-    };
-    registerConsoleCommand(command: string, handler: (...args: string[]) => Promise<string>, doc?: string): void;
-    runConsoleCommand(command: string, args: string[]): Promise<string>;
-    triggerPhysicsDebugView(): void;
+    get physicsDebugViewActive(): boolean;
+    set physicsDebugViewActive(value: boolean);
 }

package/dist/base/gg-world.js

@@ -7,67 +7,41 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-import { GgConsoleUI, GgDebuggerUI, GgGlobalClock, GgStatic, TickOrder, KeyboardInput, } from '../base';
-import { filter } from 'rxjs';
+import { GgGlobalClock, KeyboardInput, TickOrder, } from '../base';
 export class GgWorld {
-    constructor(visualScene, physicsWorld, consoleEnabled = false) {
+    constructor(visualScene, physicsWorld) {
         this.visualScene = visualScene;
         this.physicsWorld = physicsWorld;
-        this.consoleEnabled = consoleEnabled;
         this.worldClock = GgGlobalClock.instance.createChildClock(false);
         this.keyboardInput = new KeyboardInput();
+        this.name = 'w0x' + (GgWorld.default_name_counter++).toString(16);
         this.children = [];
         // the same as children, but sorted by tick order
         this.tickListeners = [];
-        this.commands = {};
-        GgStatic.instance.worlds.push(this);
-        GgStatic.instance.selectedWorld = this;
+        GgWorld._documentWorlds.push(this);
         this.keyboardInput.start();
-        if (consoleEnabled) {
-            // TODO this listener should be outside of the world
-            this.keyboardInput
-                .bind('Backquote')
-                .pipe(filter(x => x))
-                .subscribe(() => {
-                // open console UI
-                if (GgConsoleUI.instance.isUIShown) {
-                    GgConsoleUI.instance.destroyUI();
-                }
-                else {
-                    GgConsoleUI.instance.createUI();
-                }
-            });
-            this.registerConsoleCommand('commandslist', () => __awaiter(this, void 0, void 0, function* () {
-                return Object.entries(this.commands)
-                    .map(([key, value]) => `${key}${value.doc ? '\t// ' + value.doc : ''}`)
-                    .sort()
-                    .join('\n\n');
-            }), 'no args; print all available commands');
-            this.registerConsoleCommand('debugger', (...args) => __awaiter(this, void 0, void 0, function* () {
-                const shouldDraw = ['1', 'true', '+'].includes(args[0]);
-                if (shouldDraw != GgDebuggerUI.instance.isUIShown) {
-                    if (GgDebuggerUI.instance.isUIShown) {
-                        GgDebuggerUI.instance.destroyUI();
-                    }
-                    else {
-                        GgDebuggerUI.instance.createUI();
-                    }
-                }
-                return '' + GgDebuggerUI.instance.isUIShown;
+        if (window.ggstatic) {
+            window.ggstatic.registerConsoleCommand(this, 'show_debugger', (...args) => __awaiter(this, void 0, void 0, function* () {
+                window.ggstatic.showDebugControls = ['1', 'true', '+'].includes(args[0]);
+                return '' + window.ggstatic.showDebugControls;
             }), 'args: [0 or 1]; turn on/off debug panel. Default value is 0');
-            this.registerConsoleCommand('ph_timescale', (...args) => __awaiter(this, void 0, void 0, function* () {
+            window.ggstatic.registerConsoleCommand(this, 'show_stats', (...args) => __awaiter(this, void 0, void 0, function* () {
+                window.ggstatic.showStats = ['1', 'true', '+'].includes(args[0]);
+                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);
             }), 'args: [float]; change time scale of physics engine. Default value is 1.0');
-            this.registerConsoleCommand('dr_drawphysics', (...args) => __awaiter(this, void 0, void 0, function* () {
-                const shouldDraw = ['1', 'true', '+'].includes(args[0]);
-                if (shouldDraw != this.physicsWorld.physicsDebugViewActive) {
-                    this.triggerPhysicsDebugView();
-                }
+            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');
         }
     }
+    static get documentWorlds() {
+        return [...GgWorld._documentWorlds];
+    }
     init() {
         return __awaiter(this, void 0, void 0, function* () {
             yield Promise.all([this.physicsWorld.init(), this.visualScene.init()]);
@@ -115,6 +89,9 @@ export class GgWorld {
         return this.worldClock.createChildClock(autoStart);
     }
     dispose() {
+        if (window.ggstatic) {
+            window.ggstatic.deregisterWorldCommands(this);
+        }
         this.worldClock.stop();
         this.keyboardInput.stop();
         for (let i = 0; i < this.children.length; i++) {
@@ -149,33 +126,24 @@ export class GgWorld {
             entity.dispose();
         }
     }
-    registerConsoleCommand(command, handler, doc) {
-        if (!this.consoleEnabled) {
-            throw new Error('Console not enabled for this world');
-        }
-        this.commands[command] = { handler, doc };
+    get physicsDebugViewActive() {
+        return this.physicsWorld.physicsDebugViewActive;
     }
-    runConsoleCommand(command, args) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!this.consoleEnabled) {
-                throw new Error('Console not enabled for this world');
-            }
-            if (!this.commands[command]) {
-                return 'Unrecognized command: ' + command;
-            }
-            return this.commands[command].handler(...args);
-        });
-    }
-    triggerPhysicsDebugView() {
-        if (this.physicsWorld.physicsDebugViewActive) {
-            this.physicsWorld.stopDebugger(this);
+    set physicsDebugViewActive(value) {
+        if (this.physicsDebugViewActive === value) {
+            return;
         }
-        else {
+        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

@@ -1,6 +1,7 @@
 export * from './clock/global-clock';
 export * from './clock/i-clock';
 export * from './clock/pausable-clock';
+export * from './components/physics/i-body.component';
 export * from './components/physics/i-rigid-body.component';
 export * from './components/physics/i-trigger.component';
 export * from './components/physics/i-physics-world.component';
@@ -31,7 +32,5 @@ export * from './math/point3';
 export * from './math/quaternion';
 export * from './math/numbers';
 export * from './math/matrix4';
-export * from './ui/gg-console.ui';
-export * from './ui/gg-debugger.ui';
-export * from './gg-static';
+export * from './math/splines';
 export * from './gg-world';

package/dist/base/index.js

@@ -1,6 +1,7 @@
 export * from './clock/global-clock';
 export * from './clock/i-clock';
 export * from './clock/pausable-clock';
+export * from './components/physics/i-body.component';
 export * from './components/physics/i-rigid-body.component';
 export * from './components/physics/i-trigger.component';
 export * from './components/physics/i-physics-world.component';
@@ -31,7 +32,5 @@ export * from './math/point3';
 export * from './math/quaternion';
 export * from './math/numbers';
 export * from './math/matrix4';
-export * from './ui/gg-console.ui';
-export * from './ui/gg-debugger.ui';
-export * from './gg-static';
+export * from './math/splines';
 export * from './gg-world';

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

@@ -6,6 +6,10 @@ export declare class Pnt2 {
     static get X(): Point2;
     /** basis Y vector */
     static get Y(): Point2;
+    /** basis -X vector */
+    static get nX(): Point2;
+    /** basis -Y vector */
+    static get nY(): Point2;
     /** clone point */
     static clone(p: Point2): Point2;
     /** add point b to point a */

package/dist/base/math/point2.js

@@ -11,6 +11,14 @@ export class Pnt2 {
     static get Y() {
         return { x: 0, y: 1 };
     }
+    /** basis -X vector */
+    static get nX() {
+        return { x: -1, y: 0 };
+    }
+    /** basis -Y vector */
+    static get nY() {
+        return { x: 0, y: -1 };
+    }
     /** clone point */
     static clone(p) {
         return { x: p.x, y: p.y };

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

@@ -8,6 +8,12 @@ export declare class Pnt3 {
     static get Y(): Point3;
     /** basis Z vector */
     static get Z(): Point3;
+    /** basis -X vector */
+    static get nX(): Point3;
+    /** basis -Y vector */
+    static get nY(): Point3;
+    /** basis -Z vector */
+    static get nZ(): Point3;
     /** clone point */
     static clone(p: Point3): Point3;
     /** add point b to point a */

package/dist/base/math/point3.js

@@ -16,6 +16,18 @@ export class Pnt3 {
     static get Z() {
         return { x: 0, y: 0, z: 1 };
     }
+    /** basis -X vector */
+    static get nX() {
+        return { x: -1, y: 0, z: 0 };
+    }
+    /** basis -Y vector */
+    static get nY() {
+        return { x: 0, y: -1, z: 0 };
+    }
+    /** basis -Z vector */
+    static get nZ() {
+        return { x: 0, y: 0, z: -1 };
+    }
     /** clone point */
     static clone(p) {
         return { x: p.x, y: p.y, z: p.z };

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

@@ -0,0 +1 @@
+export declare const cubicSplineInterpolation: (x: number, x0: number, x1: number, y0: number, y1: number, m0: number, m1: number) => number;

package/dist/base/math/splines.js

@@ -0,0 +1,7 @@
+export const cubicSplineInterpolation = (x, x0, x1, y0, y1, m0, m1) => {
+    const h = x1 - x0;
+    return (((m0 + m1 - (2 * (y1 - y0)) / h) / h ** 2) * (x - x0) ** 3 +
+        (((3 * (y1 - y0)) / h - 2 * m0 - m1) / h) * (x - x0) ** 2 +
+        m0 * (x - x0) +
+        y0);
+};

package/dist/{base/ui → dev}/gg-console.ui.d.ts

@@ -1,14 +1,11 @@
 export declare class GgConsoleUI {
-    private static _instance;
-    static get instance(): GgConsoleUI;
-    private constructor();
     private output;
     private commandHistory;
     private currentCommandIndex;
     elements: {
         main: HTMLDivElement;
         input: HTMLInputElement;
-        output: HTMLTextAreaElement;
+        output: HTMLDivElement;
     } | null;
     get isUIShown(): boolean;
     createUI(): void;

package/dist/{base/ui → dev}/gg-console.ui.js

@@ -7,7 +7,6 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-import { GgStatic } from '../gg-static';
 export class GgConsoleUI {
     constructor() {
         this.output = `
@@ -25,18 +24,11 @@ export class GgConsoleUI {
 Welcome to GG web engine UI console. 
 Enter command in input below.
 
-List of available commands: commandslist 
-`;
+List of available commands: `.replace(/ /g, '&nbsp;') + `<span style="color:yellow">ls_commands</span>`;
         this.commandHistory = [];
         this.currentCommandIndex = 0; // for repeating command using up/down arrow keys
         this.elements = null;
     }
-    static get instance() {
-        if (!this._instance) {
-            this._instance = new GgConsoleUI();
-        }
-        return this._instance;
-    }
     get isUIShown() {
         return !!this.elements;
     }
@@ -46,28 +38,34 @@ List of available commands: commandslist
         }
         const main = document.createElement('div');
         main.innerHTML = `
-  <div id="gg-console-header" style="padding: 10px; cursor: move; z-index: 10; background-color: #054a81; border: 1px solid white; font-size: large;">GG web engine UI console</div>
-  <textarea id="gg-console-output" disabled style="resize: none; flex-grow: 1; background: #555555; border: 1px solid white; color: white; font-family: monospace;" ></textarea>
-  <input id="gg-console-input" style="background: #555555; border: 1px solid white; color: white; font-family: monospace;"/>`;
+  <div id='gg-console-header' style='padding: 0.2rem 0.2rem 0;cursor:move;display:flex;justify-content:space-between;'>
+    <span>CONSOLE</span>
+    <a id='gg-console-close-icon' style='display:block;padding:0.3rem;margin:-0.3rem;cursor:pointer;color:white;'>X</a>
+  </div>
+  <div id='gg-console-output' style='flex-grow:1;background:#232323;color:white;font-family:monospace;overflow-y:auto;overflow-wrap:anywhere;padding:0.2rem;'></div>
+  <input id='gg-console-input' style='background:#000000;border:none;outline:none;color:white;font-family:monospace;'/>`;
         main.style.position = 'absolute';
         main.style.zIndex = '1000';
-        main.style.backgroundColor = '#222222';
-        main.style.border = '1px solid white';
+        main.style.backgroundColor = '#343434';
         main.style.width = '640px';
         main.style.height = '480px';
         main.style.display = 'flex';
         main.style.flexDirection = 'column';
         main.style.alignItems = 'stretch';
-        main.style.padding = '3px';
+        main.style.padding = '0.1rem';
         main.style.rowGap = '3px';
+        main.style.fontSize = '14px';
         main.style.fontFamily = 'monospace';
+        main.style.fontWeight = 'bold';
         main.style.color = 'white';
+        main.style.textAlign = 'left';
         document.body.append(main);
         this.elements = {
             main,
             input: document.getElementById('gg-console-input'),
             output: document.getElementById('gg-console-output'),
         };
+        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) {
                 event.preventDefault();
@@ -82,6 +80,22 @@ List of available commands: commandslist
                 this.onUseNextCommand();
             }
         };
+        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) {
+                this.elements.input.value = autocompletion[0];
+                this.elements.input.setSelectionRange(value.length, this.elements.input.value.length);
+            }
+        };
         this.stdout();
         this.setupDragging();
         setTimeout(() => this.elements.input.focus(), 20);
@@ -115,14 +129,14 @@ List of available commands: commandslist
             const command = this.elements.input.value;
             this.elements.input.value = '';
             this.stdout('\n> ' + command);
-            this.stdout('\n' + (yield GgStatic.instance.console(command)));
+            this.stdout('\n' + (yield window.ggstatic.console(command)));
             this.commandHistory.push(command);
             this.currentCommandIndex = this.commandHistory.length;
         });
     }
     stdout(s = '') {
         this.output += s;
-        this.elements.output.value = this.output;
+        this.elements.output.innerHTML = this.output.replace(/\n/g, '<br>');
         this.elements.output.scrollTop = this.elements.output.scrollHeight;
     }
     setupDragging() {
@@ -138,6 +152,10 @@ List of available commands: commandslist
             document.onmousemove = elementDrag;
         };
         const elementDrag = (e) => {
+            if (!this.elements) {
+                closeDragElement();
+                return;
+            }
             e.preventDefault();
             // calculate the new cursor position:
             const curX = x - e.clientX;

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

@@ -0,0 +1,11 @@
+import { GgWorld } from '../base';
+export declare class GgDebuggerUI {
+    private ui;
+    private statsRemoved$;
+    get showStats(): boolean;
+    private currentWorld;
+    setShowStats(selectedWorld: GgWorld<any, any>, value: boolean): void;
+    private debugControlsRemoved$;
+    get showDebugControls(): boolean;
+    setShowDebugControls(selectedWorld: GgWorld<any, any>, value: boolean): void;
+}

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

@@ -0,0 +1,111 @@
+import { createInlineTickController } from '../base';
+import { fromEvent, Subject, takeUntil } from 'rxjs';
+import Stats from 'stats.js';
+export class GgDebuggerUI {
+    constructor() {
+        this.ui = {
+            stats: null,
+            debugControlsContainer: null,
+        };
+        this.statsRemoved$ = new Subject();
+        this.currentWorld = null;
+        this.debugControlsRemoved$ = new Subject();
+    }
+    get showStats() {
+        return !!this.ui.stats;
+    }
+    setShowStats(selectedWorld, value) {
+        if (value === this.showStats) {
+            if (value && this.currentWorld !== selectedWorld) {
+                this.setShowStats(this.currentWorld, false);
+            }
+            else {
+                return;
+            }
+        }
+        this.currentWorld = selectedWorld;
+        if (value) {
+            const stats = new Stats();
+            this.ui.stats = stats;
+            stats.dom.style.left = 'unset';
+            stats.dom.style.right = '0';
+            stats.showPanel(0); // 0: fps, 1: ms, 2: mb
+            document.body.appendChild(stats.dom);
+            createInlineTickController(selectedWorld, -1)
+                .pipe(takeUntil(this.statsRemoved$))
+                .subscribe(() => {
+                stats === null || stats === void 0 ? void 0 : stats.begin();
+            });
+            createInlineTickController(selectedWorld, 10000)
+                .pipe(takeUntil(this.statsRemoved$))
+                .subscribe(() => {
+                stats === null || stats === void 0 ? void 0 : stats.end();
+            });
+        }
+        else {
+            this.statsRemoved$.next();
+            document.body.removeChild(this.ui.stats.dom);
+            this.ui.stats.end();
+            this.ui.stats = null;
+        }
+    }
+    get showDebugControls() {
+        return !!this.ui.debugControlsContainer;
+    }
+    setShowDebugControls(selectedWorld, value) {
+        if (value === this.showDebugControls) {
+            if (value && this.currentWorld !== selectedWorld) {
+                this.setShowDebugControls(this.currentWorld, false);
+            }
+            else {
+                return;
+            }
+        }
+        this.currentWorld = selectedWorld;
+        if (value) {
+            const debugControlsContainer = document.createElement('div');
+            this.ui.debugControlsContainer = debugControlsContainer;
+            const debugLabelCss = "style='display:flex;align-items:center;margin:0.25rem;'";
+            debugControlsContainer.style.cssText =
+                'position:fixed;top:48px;right:0;opacity:0.9;z-index:9999;background-color:#333;color:white;display:flex;flex-direction:column';
+            debugControlsContainer.innerHTML = `
+      <div ${debugLabelCss}>
+        <input type='checkbox' name='checkbox' id='physics_debugger_checkbox_id' value='1'${this.currentWorld.physicsWorld.physicsDebugViewActive ? ' checked' : ''}>
+        <label for='physics_debugger_checkbox_id' style='user-select: none;'>Show physics bodies in scene</label>
+      </div>`;
+            // <div ${debugLabelCss}>
+            //   <input id="time_scale_slider" type="range" min="0" max="10" step="0.1" style="flex-grow:1" value="${
+            //      this.currentWorld.physicsWorld.timeScale
+            //   }"/>
+            //   <label for="time_scale_slider" style="user-select: none;">Time scale</label>
+            // </div>`;
+            document.body.appendChild(debugControlsContainer);
+            fromEvent(document.getElementById('physics_debugger_checkbox_id'), 'change')
+                .pipe(takeUntil(this.debugControlsRemoved$))
+                .subscribe(e => {
+                try {
+                    this.currentWorld.physicsDebugViewActive = e.target.checked;
+                }
+                catch (err) {
+                    console.error(err);
+                }
+                e.target.checked = this.currentWorld.physicsDebugViewActive;
+            });
+            // fromEvent(document.getElementById('time_scale_slider')! as HTMLInputElement, 'change')
+            //   .pipe(takeUntil(this.debugControlsRemoved$))
+            //   .subscribe(e => {
+            //     try {
+            //        this.currentWorld.physicsWorld.timeScale = +(e.target as HTMLInputElement).value;
+            //     } catch (err) {
+            //       console.error(err);
+            //     }
+            //     (e.target as HTMLInputElement).value = '' + ( this.currentWorld.physicsWorld.timeScale || 1);
+            //   });
+        }
+        else {
+            this.debugControlsRemoved$.next();
+            document.body.removeChild(this.ui.debugControlsContainer);
+            this.ui.debugControlsContainer = null;
+        }
+    }
+}

package/dist/dev/gg-static.d.ts

@@ -0,0 +1,32 @@
+import { GgWorld } from '../base';
+export declare class GgStatic {
+    private static _instance;
+    static get instance(): GgStatic;
+    private readonly debuggerUI;
+    private readonly consoleUI;
+    private _devConsoleEnabled;
+    get devConsoleEnabled(): boolean;
+    consoleKeyPressEventListener: (event: KeyboardEvent) => void;
+    set devConsoleEnabled(value: boolean);
+    get showStats(): boolean;
+    set showStats(value: boolean);
+    get showDebugControls(): boolean;
+    set showDebugControls(value: boolean);
+    private _selectedWorld;
+    get selectedWorld(): GgWorld<any, any> | null;
+    get availableCommands(): [string, {
+        handler: (...args: string[]) => Promise<string>;
+        doc?: string;
+    }][];
+    private constructor();
+    protected consoleCommands: Map<GgWorld<any, any> | null, {
+        [key: string]: {
+            handler: (...args: string[]) => Promise<string>;
+            doc?: string;
+        };
+    }>;
+    registerConsoleCommand(world: GgWorld<any, any> | null, command: string, handler: (...args: string[]) => Promise<string>, doc?: string): void;
+    deregisterWorldCommands(world: GgWorld<any, any> | null): void;
+    console(input: string): Promise<string>;
+    runConsoleCommand(command: string, args: string[]): Promise<string>;
+}